clang 22.0.0git
SemaDeclCXX.cpp
Go to the documentation of this file.
1//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis for C++ declarations.
10//
11//===----------------------------------------------------------------------===//
12
13#include "TypeLocBuilder.h"
18#include "clang/AST/CharUnits.h"
20#include "clang/AST/DeclCXX.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/ExprCXX.h"
28#include "clang/AST/TypeLoc.h"
37#include "clang/Sema/DeclSpec.h"
40#include "clang/Sema/Lookup.h"
43#include "clang/Sema/Scope.h"
45#include "clang/Sema/SemaCUDA.h"
47#include "clang/Sema/SemaObjC.h"
49#include "clang/Sema/Template.h"
51#include "llvm/ADT/ArrayRef.h"
52#include "llvm/ADT/STLExtras.h"
53#include "llvm/ADT/StringExtras.h"
54#include "llvm/Support/ConvertUTF.h"
55#include "llvm/Support/SaveAndRestore.h"
56#include <map>
57#include <optional>
58#include <set>
59
60using namespace clang;
61
62//===----------------------------------------------------------------------===//
63// CheckDefaultArgumentVisitor
64//===----------------------------------------------------------------------===//
65
66namespace {
67/// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
68/// the default argument of a parameter to determine whether it
69/// contains any ill-formed subexpressions. For example, this will
70/// diagnose the use of local variables or parameters within the
71/// default argument expression.
72class CheckDefaultArgumentVisitor
73 : public ConstStmtVisitor<CheckDefaultArgumentVisitor, bool> {
74 Sema &S;
75 const Expr *DefaultArg;
76
77public:
78 CheckDefaultArgumentVisitor(Sema &S, const Expr *DefaultArg)
79 : S(S), DefaultArg(DefaultArg) {}
80
81 bool VisitExpr(const Expr *Node);
82 bool VisitDeclRefExpr(const DeclRefExpr *DRE);
83 bool VisitCXXThisExpr(const CXXThisExpr *ThisE);
84 bool VisitLambdaExpr(const LambdaExpr *Lambda);
85 bool VisitPseudoObjectExpr(const PseudoObjectExpr *POE);
86};
87
88/// VisitExpr - Visit all of the children of this expression.
89bool CheckDefaultArgumentVisitor::VisitExpr(const Expr *Node) {
90 bool IsInvalid = false;
91 for (const Stmt *SubStmt : Node->children())
92 if (SubStmt)
93 IsInvalid |= Visit(SubStmt);
94 return IsInvalid;
95}
96
97/// VisitDeclRefExpr - Visit a reference to a declaration, to
98/// determine whether this declaration can be used in the default
99/// argument expression.
100bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(const DeclRefExpr *DRE) {
101 const ValueDecl *Decl = dyn_cast<ValueDecl>(DRE->getDecl());
102
103 if (!isa<VarDecl, BindingDecl>(Decl))
104 return false;
105
106 if (const auto *Param = dyn_cast<ParmVarDecl>(Decl)) {
107 // C++ [dcl.fct.default]p9:
108 // [...] parameters of a function shall not be used in default
109 // argument expressions, even if they are not evaluated. [...]
110 //
111 // C++17 [dcl.fct.default]p9 (by CWG 2082):
112 // [...] A parameter shall not appear as a potentially-evaluated
113 // expression in a default argument. [...]
114 //
115 if (DRE->isNonOdrUse() != NOUR_Unevaluated)
116 return S.Diag(DRE->getBeginLoc(),
117 diag::err_param_default_argument_references_param)
118 << Param->getDeclName() << DefaultArg->getSourceRange();
119 } else if (auto *VD = Decl->getPotentiallyDecomposedVarDecl()) {
120 // C++ [dcl.fct.default]p7:
121 // Local variables shall not be used in default argument
122 // expressions.
123 //
124 // C++17 [dcl.fct.default]p7 (by CWG 2082):
125 // A local variable shall not appear as a potentially-evaluated
126 // expression in a default argument.
127 //
128 // C++20 [dcl.fct.default]p7 (DR as part of P0588R1, see also CWG 2346):
129 // Note: A local variable cannot be odr-used (6.3) in a default
130 // argument.
131 //
132 if (VD->isLocalVarDecl() && !DRE->isNonOdrUse())
133 return S.Diag(DRE->getBeginLoc(),
134 diag::err_param_default_argument_references_local)
135 << Decl << DefaultArg->getSourceRange();
136 }
137 return false;
138}
139
140/// VisitCXXThisExpr - Visit a C++ "this" expression.
141bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(const CXXThisExpr *ThisE) {
142 // C++ [dcl.fct.default]p8:
143 // The keyword this shall not be used in a default argument of a
144 // member function.
145 return S.Diag(ThisE->getBeginLoc(),
146 diag::err_param_default_argument_references_this)
147 << ThisE->getSourceRange();
148}
149
150bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
151 const PseudoObjectExpr *POE) {
152 bool Invalid = false;
153 for (const Expr *E : POE->semantics()) {
154 // Look through bindings.
155 if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {
156 E = OVE->getSourceExpr();
157 assert(E && "pseudo-object binding without source expression?");
158 }
159
160 Invalid |= Visit(E);
161 }
162 return Invalid;
163}
164
165bool CheckDefaultArgumentVisitor::VisitLambdaExpr(const LambdaExpr *Lambda) {
166 // [expr.prim.lambda.capture]p9
167 // a lambda-expression appearing in a default argument cannot implicitly or
168 // explicitly capture any local entity. Such a lambda-expression can still
169 // have an init-capture if any full-expression in its initializer satisfies
170 // the constraints of an expression appearing in a default argument.
171 bool Invalid = false;
172 for (const LambdaCapture &LC : Lambda->captures()) {
173 if (!Lambda->isInitCapture(&LC))
174 return S.Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
175 // Init captures are always VarDecl.
176 auto *D = cast<VarDecl>(LC.getCapturedVar());
177 Invalid |= Visit(D->getInit());
178 }
179 return Invalid;
180}
181} // namespace
182
183void
185 const CXXMethodDecl *Method) {
186 // If we have an MSAny spec already, don't bother.
187 if (!Method || ComputedEST == EST_MSAny)
188 return;
189
190 const FunctionProtoType *Proto
191 = Method->getType()->getAs<FunctionProtoType>();
192 Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
193 if (!Proto)
194 return;
195
197
198 // If we have a throw-all spec at this point, ignore the function.
199 if (ComputedEST == EST_None)
200 return;
201
202 if (EST == EST_None && Method->hasAttr<NoThrowAttr>())
203 EST = EST_BasicNoexcept;
204
205 switch (EST) {
206 case EST_Unparsed:
208 case EST_Unevaluated:
209 llvm_unreachable("should not see unresolved exception specs here");
210
211 // If this function can throw any exceptions, make a note of that.
212 case EST_MSAny:
213 case EST_None:
214 // FIXME: Whichever we see last of MSAny and None determines our result.
215 // We should make a consistent, order-independent choice here.
216 ClearExceptions();
217 ComputedEST = EST;
218 return;
220 ClearExceptions();
221 ComputedEST = EST_None;
222 return;
223 // FIXME: If the call to this decl is using any of its default arguments, we
224 // need to search them for potentially-throwing calls.
225 // If this function has a basic noexcept, it doesn't affect the outcome.
227 case EST_NoexceptTrue:
228 case EST_NoThrow:
229 return;
230 // If we're still at noexcept(true) and there's a throw() callee,
231 // change to that specification.
232 case EST_DynamicNone:
233 if (ComputedEST == EST_BasicNoexcept)
234 ComputedEST = EST_DynamicNone;
235 return;
237 llvm_unreachable(
238 "should not generate implicit declarations for dependent cases");
239 case EST_Dynamic:
240 break;
241 }
242 assert(EST == EST_Dynamic && "EST case not considered earlier.");
243 assert(ComputedEST != EST_None &&
244 "Shouldn't collect exceptions when throw-all is guaranteed.");
245 ComputedEST = EST_Dynamic;
246 // Record the exceptions in this function's exception specification.
247 for (const auto &E : Proto->exceptions())
248 if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
249 Exceptions.push_back(E);
250}
251
253 if (!S || ComputedEST == EST_MSAny)
254 return;
255
256 // FIXME:
257 //
258 // C++0x [except.spec]p14:
259 // [An] implicit exception-specification specifies the type-id T if and
260 // only if T is allowed by the exception-specification of a function directly
261 // invoked by f's implicit definition; f shall allow all exceptions if any
262 // function it directly invokes allows all exceptions, and f shall allow no
263 // exceptions if every function it directly invokes allows no exceptions.
264 //
265 // Note in particular that if an implicit exception-specification is generated
266 // for a function containing a throw-expression, that specification can still
267 // be noexcept(true).
268 //
269 // Note also that 'directly invoked' is not defined in the standard, and there
270 // is no indication that we should only consider potentially-evaluated calls.
271 //
272 // Ultimately we should implement the intent of the standard: the exception
273 // specification should be the set of exceptions which can be thrown by the
274 // implicit definition. For now, we assume that any non-nothrow expression can
275 // throw any exception.
276
277 if (Self->canThrow(S))
278 ComputedEST = EST_None;
279}
280
282 SourceLocation EqualLoc) {
283 if (RequireCompleteType(Param->getLocation(), Param->getType(),
284 diag::err_typecheck_decl_incomplete_type))
285 return true;
286
287 // C++ [dcl.fct.default]p5
288 // A default argument expression is implicitly converted (clause
289 // 4) to the parameter type. The default argument expression has
290 // the same semantic constraints as the initializer expression in
291 // a declaration of a variable of the parameter type, using the
292 // copy-initialization semantics (8.5).
294 Param);
296 EqualLoc);
297 InitializationSequence InitSeq(*this, Entity, Kind, Arg);
298 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
299 if (Result.isInvalid())
300 return true;
301 Arg = Result.getAs<Expr>();
302
303 CheckCompletedExpr(Arg, EqualLoc);
305
306 return Arg;
307}
308
310 SourceLocation EqualLoc) {
311 // Add the default argument to the parameter
312 Param->setDefaultArg(Arg);
313
314 // We have already instantiated this parameter; provide each of the
315 // instantiations with the uninstantiated default argument.
316 UnparsedDefaultArgInstantiationsMap::iterator InstPos
318 if (InstPos != UnparsedDefaultArgInstantiations.end()) {
319 for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
320 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
321
322 // We're done tracking this parameter's instantiations.
324 }
325}
326
327void
329 Expr *DefaultArg) {
330 if (!param || !DefaultArg)
331 return;
332
333 ParmVarDecl *Param = cast<ParmVarDecl>(param);
334 UnparsedDefaultArgLocs.erase(Param);
335
336 // Default arguments are only permitted in C++
337 if (!getLangOpts().CPlusPlus) {
338 Diag(EqualLoc, diag::err_param_default_argument)
339 << DefaultArg->getSourceRange();
340 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
341 }
342
343 // Check for unexpanded parameter packs.
345 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
346
347 // C++11 [dcl.fct.default]p3
348 // A default argument expression [...] shall not be specified for a
349 // parameter pack.
350 if (Param->isParameterPack()) {
351 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
352 << DefaultArg->getSourceRange();
353 // Recover by discarding the default argument.
354 Param->setDefaultArg(nullptr);
355 return;
356 }
357
358 ExprResult Result = ConvertParamDefaultArgument(Param, DefaultArg, EqualLoc);
359 if (Result.isInvalid())
360 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
361
362 DefaultArg = Result.getAs<Expr>();
363
364 // Check that the default argument is well-formed
365 CheckDefaultArgumentVisitor DefaultArgChecker(*this, DefaultArg);
366 if (DefaultArgChecker.Visit(DefaultArg))
367 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
368
369 SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
370}
371
373 SourceLocation EqualLoc,
374 SourceLocation ArgLoc) {
375 if (!param)
376 return;
377
378 ParmVarDecl *Param = cast<ParmVarDecl>(param);
379 Param->setUnparsedDefaultArg();
380 UnparsedDefaultArgLocs[Param] = ArgLoc;
381}
382
384 Expr *DefaultArg) {
385 if (!param)
386 return;
387
388 ParmVarDecl *Param = cast<ParmVarDecl>(param);
389 Param->setInvalidDecl();
390 UnparsedDefaultArgLocs.erase(Param);
391 ExprResult RE;
392 if (DefaultArg) {
393 RE = CreateRecoveryExpr(EqualLoc, DefaultArg->getEndLoc(), {DefaultArg},
394 Param->getType().getNonReferenceType());
395 } else {
396 RE = CreateRecoveryExpr(EqualLoc, EqualLoc, {},
397 Param->getType().getNonReferenceType());
398 }
399 Param->setDefaultArg(RE.get());
400}
401
403 // C++ [dcl.fct.default]p3
404 // A default argument expression shall be specified only in the
405 // parameter-declaration-clause of a function declaration or in a
406 // template-parameter (14.1). It shall not be specified for a
407 // parameter pack. If it is specified in a
408 // parameter-declaration-clause, it shall not occur within a
409 // declarator or abstract-declarator of a parameter-declaration.
410 bool MightBeFunction = D.isFunctionDeclarationContext();
411 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
412 DeclaratorChunk &chunk = D.getTypeObject(i);
413 if (chunk.Kind == DeclaratorChunk::Function) {
414 if (MightBeFunction) {
415 // This is a function declaration. It can have default arguments, but
416 // keep looking in case its return type is a function type with default
417 // arguments.
418 MightBeFunction = false;
419 continue;
420 }
421 for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
422 ++argIdx) {
423 ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
424 if (Param->hasUnparsedDefaultArg()) {
425 std::unique_ptr<CachedTokens> Toks =
426 std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
427 SourceRange SR;
428 if (Toks->size() > 1)
429 SR = SourceRange((*Toks)[1].getLocation(),
430 Toks->back().getLocation());
431 else
432 SR = UnparsedDefaultArgLocs[Param];
433 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
434 << SR;
435 } else if (Param->getDefaultArg()) {
436 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
437 << Param->getDefaultArg()->getSourceRange();
438 Param->setDefaultArg(nullptr);
439 }
440 }
441 } else if (chunk.Kind != DeclaratorChunk::Paren) {
442 MightBeFunction = false;
443 }
444 }
445}
446
448 return llvm::any_of(FD->parameters(), [](ParmVarDecl *P) {
449 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
450 });
451}
452
454 Scope *S) {
455 bool Invalid = false;
456
457 // The declaration context corresponding to the scope is the semantic
458 // parent, unless this is a local function declaration, in which case
459 // it is that surrounding function.
460 DeclContext *ScopeDC = New->isLocalExternDecl()
461 ? New->getLexicalDeclContext()
462 : New->getDeclContext();
463
464 // Find the previous declaration for the purpose of default arguments.
465 FunctionDecl *PrevForDefaultArgs = Old;
466 for (/**/; PrevForDefaultArgs;
467 // Don't bother looking back past the latest decl if this is a local
468 // extern declaration; nothing else could work.
469 PrevForDefaultArgs = New->isLocalExternDecl()
470 ? nullptr
471 : PrevForDefaultArgs->getPreviousDecl()) {
472 // Ignore hidden declarations.
473 if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
474 continue;
475
476 if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
477 !New->isCXXClassMember()) {
478 // Ignore default arguments of old decl if they are not in
479 // the same scope and this is not an out-of-line definition of
480 // a member function.
481 continue;
482 }
483
484 if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
485 // If only one of these is a local function declaration, then they are
486 // declared in different scopes, even though isDeclInScope may think
487 // they're in the same scope. (If both are local, the scope check is
488 // sufficient, and if neither is local, then they are in the same scope.)
489 continue;
490 }
491
492 // We found the right previous declaration.
493 break;
494 }
495
496 // C++ [dcl.fct.default]p4:
497 // For non-template functions, default arguments can be added in
498 // later declarations of a function in the same
499 // scope. Declarations in different scopes have completely
500 // distinct sets of default arguments. That is, declarations in
501 // inner scopes do not acquire default arguments from
502 // declarations in outer scopes, and vice versa. In a given
503 // function declaration, all parameters subsequent to a
504 // parameter with a default argument shall have default
505 // arguments supplied in this or previous declarations. A
506 // default argument shall not be redefined by a later
507 // declaration (not even to the same value).
508 //
509 // C++ [dcl.fct.default]p6:
510 // Except for member functions of class templates, the default arguments
511 // in a member function definition that appears outside of the class
512 // definition are added to the set of default arguments provided by the
513 // member function declaration in the class definition.
514 for (unsigned p = 0, NumParams = PrevForDefaultArgs
515 ? PrevForDefaultArgs->getNumParams()
516 : 0;
517 p < NumParams; ++p) {
518 ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
519 ParmVarDecl *NewParam = New->getParamDecl(p);
520
521 bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
522 bool NewParamHasDfl = NewParam->hasDefaultArg();
523
524 if (OldParamHasDfl && NewParamHasDfl) {
525 unsigned DiagDefaultParamID =
526 diag::err_param_default_argument_redefinition;
527
528 // MSVC accepts that default parameters be redefined for member functions
529 // of template class. The new default parameter's value is ignored.
530 Invalid = true;
531 if (getLangOpts().MicrosoftExt) {
532 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
533 if (MD && MD->getParent()->getDescribedClassTemplate()) {
534 // Merge the old default argument into the new parameter.
535 NewParam->setHasInheritedDefaultArg();
536 if (OldParam->hasUninstantiatedDefaultArg())
538 OldParam->getUninstantiatedDefaultArg());
539 else
540 NewParam->setDefaultArg(OldParam->getInit());
541 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
542 Invalid = false;
543 }
544 }
545
546 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
547 // hint here. Alternatively, we could walk the type-source information
548 // for NewParam to find the last source location in the type... but it
549 // isn't worth the effort right now. This is the kind of test case that
550 // is hard to get right:
551 // int f(int);
552 // void g(int (*fp)(int) = f);
553 // void g(int (*fp)(int) = &f);
554 Diag(NewParam->getLocation(), DiagDefaultParamID)
555 << NewParam->getDefaultArgRange();
556
557 // Look for the function declaration where the default argument was
558 // actually written, which may be a declaration prior to Old.
559 for (auto Older = PrevForDefaultArgs;
560 OldParam->hasInheritedDefaultArg(); /**/) {
561 Older = Older->getPreviousDecl();
562 OldParam = Older->getParamDecl(p);
563 }
564
565 Diag(OldParam->getLocation(), diag::note_previous_definition)
566 << OldParam->getDefaultArgRange();
567 } else if (OldParamHasDfl) {
568 // Merge the old default argument into the new parameter unless the new
569 // function is a friend declaration in a template class. In the latter
570 // case the default arguments will be inherited when the friend
571 // declaration will be instantiated.
572 if (New->getFriendObjectKind() == Decl::FOK_None ||
573 !New->getLexicalDeclContext()->isDependentContext()) {
574 // It's important to use getInit() here; getDefaultArg()
575 // strips off any top-level ExprWithCleanups.
576 NewParam->setHasInheritedDefaultArg();
577 if (OldParam->hasUnparsedDefaultArg())
578 NewParam->setUnparsedDefaultArg();
579 else if (OldParam->hasUninstantiatedDefaultArg())
581 OldParam->getUninstantiatedDefaultArg());
582 else
583 NewParam->setDefaultArg(OldParam->getInit());
584 }
585 } else if (NewParamHasDfl) {
586 if (New->getDescribedFunctionTemplate()) {
587 // Paragraph 4, quoted above, only applies to non-template functions.
588 Diag(NewParam->getLocation(),
589 diag::err_param_default_argument_template_redecl)
590 << NewParam->getDefaultArgRange();
591 Diag(PrevForDefaultArgs->getLocation(),
592 diag::note_template_prev_declaration)
593 << false;
594 } else if (New->getTemplateSpecializationKind()
596 New->getTemplateSpecializationKind() != TSK_Undeclared) {
597 // C++ [temp.expr.spec]p21:
598 // Default function arguments shall not be specified in a declaration
599 // or a definition for one of the following explicit specializations:
600 // - the explicit specialization of a function template;
601 // - the explicit specialization of a member function template;
602 // - the explicit specialization of a member function of a class
603 // template where the class template specialization to which the
604 // member function specialization belongs is implicitly
605 // instantiated.
606 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
607 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
608 << New->getDeclName()
609 << NewParam->getDefaultArgRange();
610 } else if (New->getDeclContext()->isDependentContext()) {
611 // C++ [dcl.fct.default]p6 (DR217):
612 // Default arguments for a member function of a class template shall
613 // be specified on the initial declaration of the member function
614 // within the class template.
615 //
616 // Reading the tea leaves a bit in DR217 and its reference to DR205
617 // leads me to the conclusion that one cannot add default function
618 // arguments for an out-of-line definition of a member function of a
619 // dependent type.
620 int WhichKind = 2;
622 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
623 if (Record->getDescribedClassTemplate())
624 WhichKind = 0;
625 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
626 WhichKind = 1;
627 else
628 WhichKind = 2;
629 }
630
631 Diag(NewParam->getLocation(),
632 diag::err_param_default_argument_member_template_redecl)
633 << WhichKind
634 << NewParam->getDefaultArgRange();
635 }
636 }
637 }
638
639 // DR1344: If a default argument is added outside a class definition and that
640 // default argument makes the function a special member function, the program
641 // is ill-formed. This can only happen for constructors.
642 if (isa<CXXConstructorDecl>(New) &&
643 New->getMinRequiredArguments() < Old->getMinRequiredArguments()) {
644 CXXSpecialMemberKind NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
645 OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
646 if (NewSM != OldSM) {
647 ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
648 assert(NewParam->hasDefaultArg());
649 Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
650 << NewParam->getDefaultArgRange() << NewSM;
651 Diag(Old->getLocation(), diag::note_previous_declaration);
652 }
653 }
654
655 const FunctionDecl *Def;
656 // C++11 [dcl.constexpr]p1: If any declaration of a function or function
657 // template has a constexpr specifier then all its declarations shall
658 // contain the constexpr specifier.
659 if (New->getConstexprKind() != Old->getConstexprKind()) {
660 Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
661 << New << static_cast<int>(New->getConstexprKind())
662 << static_cast<int>(Old->getConstexprKind());
663 Diag(Old->getLocation(), diag::note_previous_declaration);
664 Invalid = true;
665 } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
666 Old->isDefined(Def) &&
667 // If a friend function is inlined but does not have 'inline'
668 // specifier, it is a definition. Do not report attribute conflict
669 // in this case, redefinition will be diagnosed later.
670 (New->isInlineSpecified() ||
671 New->getFriendObjectKind() == Decl::FOK_None)) {
672 // C++11 [dcl.fcn.spec]p4:
673 // If the definition of a function appears in a translation unit before its
674 // first declaration as inline, the program is ill-formed.
675 Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
676 Diag(Def->getLocation(), diag::note_previous_definition);
677 Invalid = true;
678 }
679
680 // C++17 [temp.deduct.guide]p3:
681 // Two deduction guide declarations in the same translation unit
682 // for the same class template shall not have equivalent
683 // parameter-declaration-clauses.
684 if (isa<CXXDeductionGuideDecl>(New) &&
685 !New->isFunctionTemplateSpecialization() && isVisible(Old)) {
686 Diag(New->getLocation(), diag::err_deduction_guide_redeclared);
687 Diag(Old->getLocation(), diag::note_previous_declaration);
688 }
689
690 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
691 // argument expression, that declaration shall be a definition and shall be
692 // the only declaration of the function or function template in the
693 // translation unit.
696 Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
697 Diag(Old->getLocation(), diag::note_previous_declaration);
698 Invalid = true;
699 }
700
701 // C++11 [temp.friend]p4 (DR329):
702 // When a function is defined in a friend function declaration in a class
703 // template, the function is instantiated when the function is odr-used.
704 // The same restrictions on multiple declarations and definitions that
705 // apply to non-template function declarations and definitions also apply
706 // to these implicit definitions.
707 const FunctionDecl *OldDefinition = nullptr;
708 if (New->isThisDeclarationInstantiatedFromAFriendDefinition() &&
709 Old->isDefined(OldDefinition, true))
710 CheckForFunctionRedefinition(New, OldDefinition);
711
712 return Invalid;
713}
714
717 ? diag::warn_cxx23_placeholder_var_definition
718 : diag::ext_placeholder_var_definition);
719}
720
721NamedDecl *
723 MultiTemplateParamsArg TemplateParamLists) {
724 assert(D.isDecompositionDeclarator());
725 const DecompositionDeclarator &Decomp = D.getDecompositionDeclarator();
726
727 // The syntax only allows a decomposition declarator as a simple-declaration,
728 // a for-range-declaration, or a condition in Clang, but we parse it in more
729 // cases than that.
730 if (!D.mayHaveDecompositionDeclarator()) {
731 Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
732 << Decomp.getSourceRange();
733 return nullptr;
734 }
735
736 if (!TemplateParamLists.empty()) {
737 // C++17 [temp]/1:
738 // A template defines a family of class, functions, or variables, or an
739 // alias for a family of types.
740 //
741 // Structured bindings are not included.
742 Diag(TemplateParamLists.front()->getTemplateLoc(),
743 diag::err_decomp_decl_template);
744 return nullptr;
745 }
746
747 unsigned DiagID;
749 DiagID = diag::compat_pre_cxx17_decomp_decl;
750 else if (D.getContext() == DeclaratorContext::Condition)
751 DiagID = getLangOpts().CPlusPlus26
752 ? diag::compat_cxx26_decomp_decl_cond
753 : diag::compat_pre_cxx26_decomp_decl_cond;
754 else
755 DiagID = diag::compat_cxx17_decomp_decl;
756
757 Diag(Decomp.getLSquareLoc(), DiagID) << Decomp.getSourceRange();
758
759 // The semantic context is always just the current context.
760 DeclContext *const DC = CurContext;
761
762 // C++17 [dcl.dcl]/8:
763 // The decl-specifier-seq shall contain only the type-specifier auto
764 // and cv-qualifiers.
765 // C++20 [dcl.dcl]/8:
766 // If decl-specifier-seq contains any decl-specifier other than static,
767 // thread_local, auto, or cv-qualifiers, the program is ill-formed.
768 // C++23 [dcl.pre]/6:
769 // Each decl-specifier in the decl-specifier-seq shall be static,
770 // thread_local, auto (9.2.9.6 [dcl.spec.auto]), or a cv-qualifier.
771 auto &DS = D.getDeclSpec();
772 {
773 // Note: While constrained-auto needs to be checked, we do so separately so
774 // we can emit a better diagnostic.
775 SmallVector<StringRef, 8> BadSpecifiers;
776 SmallVector<SourceLocation, 8> BadSpecifierLocs;
777 SmallVector<StringRef, 8> CPlusPlus20Specifiers;
778 SmallVector<SourceLocation, 8> CPlusPlus20SpecifierLocs;
779 if (auto SCS = DS.getStorageClassSpec()) {
780 if (SCS == DeclSpec::SCS_static) {
781 CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(SCS));
782 CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
783 } else {
784 BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
785 BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
786 }
787 }
788 if (auto TSCS = DS.getThreadStorageClassSpec()) {
789 CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(TSCS));
790 CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
791 }
792 if (DS.hasConstexprSpecifier()) {
793 BadSpecifiers.push_back(
794 DeclSpec::getSpecifierName(DS.getConstexprSpecifier()));
795 BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
796 }
797 if (DS.isInlineSpecified()) {
798 BadSpecifiers.push_back("inline");
799 BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
800 }
801
802 if (!BadSpecifiers.empty()) {
803 auto &&Err = Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
804 Err << (int)BadSpecifiers.size()
805 << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
806 // Don't add FixItHints to remove the specifiers; we do still respect
807 // them when building the underlying variable.
808 for (auto Loc : BadSpecifierLocs)
809 Err << SourceRange(Loc, Loc);
810 } else if (!CPlusPlus20Specifiers.empty()) {
811 auto &&Warn = DiagCompat(CPlusPlus20SpecifierLocs.front(),
812 diag_compat::decomp_decl_spec);
813 Warn << (int)CPlusPlus20Specifiers.size()
814 << llvm::join(CPlusPlus20Specifiers.begin(),
815 CPlusPlus20Specifiers.end(), " ");
816 for (auto Loc : CPlusPlus20SpecifierLocs)
817 Warn << SourceRange(Loc, Loc);
818 }
819 // We can't recover from it being declared as a typedef.
820 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
821 return nullptr;
822 }
823
824 // C++2a [dcl.struct.bind]p1:
825 // A cv that includes volatile is deprecated
826 if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) &&
828 Diag(DS.getVolatileSpecLoc(),
829 diag::warn_deprecated_volatile_structured_binding);
830
832 QualType R = TInfo->getType();
833
834 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
836 D.setInvalidType();
837
838 // The syntax only allows a single ref-qualifier prior to the decomposition
839 // declarator. No other declarator chunks are permitted. Also check the type
840 // specifier here.
841 if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
842 D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
843 (D.getNumTypeObjects() == 1 &&
844 D.getTypeObject(0).Kind != DeclaratorChunk::Reference)) {
845 Diag(Decomp.getLSquareLoc(),
846 (D.hasGroupingParens() ||
847 (D.getNumTypeObjects() &&
848 D.getTypeObject(0).Kind == DeclaratorChunk::Paren))
849 ? diag::err_decomp_decl_parens
850 : diag::err_decomp_decl_type)
851 << R;
852
853 // In most cases, there's no actual problem with an explicitly-specified
854 // type, but a function type won't work here, and ActOnVariableDeclarator
855 // shouldn't be called for such a type.
856 if (R->isFunctionType())
857 D.setInvalidType();
858 }
859
860 // Constrained auto is prohibited by [decl.pre]p6, so check that here.
861 if (DS.isConstrainedAuto()) {
862 TemplateIdAnnotation *TemplRep = DS.getRepAsTemplateId();
863 assert(TemplRep->Kind == TNK_Concept_template &&
864 "No other template kind should be possible for a constrained auto");
865
866 SourceRange TemplRange{TemplRep->TemplateNameLoc,
867 TemplRep->RAngleLoc.isValid()
868 ? TemplRep->RAngleLoc
869 : TemplRep->TemplateNameLoc};
870 Diag(TemplRep->TemplateNameLoc, diag::err_decomp_decl_constraint)
871 << TemplRange << FixItHint::CreateRemoval(TemplRange);
872 }
873
874 // Build the BindingDecls.
876
877 // Build the BindingDecls.
878 for (auto &B : D.getDecompositionDeclarator().bindings()) {
879 // Check for name conflicts.
880 DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
881 IdentifierInfo *VarName = B.Name;
882 assert(VarName && "Cannot have an unnamed binding declaration");
883
885 RedeclarationKind::ForVisibleRedeclaration);
887 /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());
888
889 // It's not permitted to shadow a template parameter name.
890 if (Previous.isSingleResult() &&
891 Previous.getFoundDecl()->isTemplateParameter()) {
892 DiagnoseTemplateParameterShadow(B.NameLoc, Previous.getFoundDecl());
893 Previous.clear();
894 }
895
896 QualType QT;
897 if (B.EllipsisLoc.isValid()) {
898 if (!cast<Decl>(DC)->isTemplated())
899 Diag(B.EllipsisLoc, diag::err_pack_outside_template);
901 /*ExpectsPackInType=*/false);
902 }
903
904 auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, B.Name, QT);
905
906 ProcessDeclAttributeList(S, BD, *B.Attrs);
907
908 // Find the shadowed declaration before filtering for scope.
909 NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()
911 : nullptr;
912
913 bool ConsiderLinkage = DC->isFunctionOrMethod() &&
914 DS.getStorageClassSpec() == DeclSpec::SCS_extern;
915 FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
916 /*AllowInlineNamespace*/false);
917
918 bool IsPlaceholder = DS.getStorageClassSpec() != DeclSpec::SCS_static &&
919 DC->isFunctionOrMethod() && VarName->isPlaceholder();
920 if (!Previous.empty()) {
921 if (IsPlaceholder) {
922 bool sameDC = (Previous.end() - 1)
923 ->getDeclContext()
924 ->getRedeclContext()
925 ->Equals(DC->getRedeclContext());
926 if (sameDC &&
927 isDeclInScope(*(Previous.end() - 1), CurContext, S, false)) {
928 Previous.clear();
930 }
931 } else {
932 auto *Old = Previous.getRepresentativeDecl();
933 Diag(B.NameLoc, diag::err_redefinition) << B.Name;
934 Diag(Old->getLocation(), diag::note_previous_definition);
935 }
936 } else if (ShadowedDecl && !D.isRedeclaration()) {
937 CheckShadow(BD, ShadowedDecl, Previous);
938 }
939 PushOnScopeChains(BD, S, true);
940 Bindings.push_back(BD);
941 ParsingInitForAutoVars.insert(BD);
942 }
943
944 // There are no prior lookup results for the variable itself, because it
945 // is unnamed.
946 DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
947 Decomp.getLSquareLoc());
949 RedeclarationKind::ForVisibleRedeclaration);
950
951 // Build the variable that holds the non-decomposed object.
952 bool AddToScope = true;
953 NamedDecl *New =
954 ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
955 MultiTemplateParamsArg(), AddToScope, Bindings);
956 if (AddToScope) {
957 S->AddDecl(New);
959 }
960
961 if (OpenMP().isInOpenMPDeclareTargetContext())
963
964 return New;
965}
966
967// Check the arity of the structured bindings.
968// Create the resolved pack expr if needed.
970 QualType DecompType,
972 unsigned MemberCount) {
973 auto BindingWithPackItr = llvm::find_if(
974 Bindings, [](BindingDecl *D) -> bool { return D->isParameterPack(); });
975 bool HasPack = BindingWithPackItr != Bindings.end();
976 bool IsValid;
977 if (!HasPack) {
978 IsValid = Bindings.size() == MemberCount;
979 } else {
980 // There may not be more members than non-pack bindings.
981 IsValid = MemberCount >= Bindings.size() - 1;
982 }
983
984 if (IsValid && HasPack) {
985 // Create the pack expr and assign it to the binding.
986 unsigned PackSize = MemberCount - Bindings.size() + 1;
987
988 BindingDecl *BPack = *BindingWithPackItr;
989 BPack->setDecomposedDecl(DD);
990 SmallVector<ValueDecl *, 8> NestedBDs(PackSize);
991 // Create the nested BindingDecls.
992 for (unsigned I = 0; I < PackSize; ++I) {
994 S.Context, BPack->getDeclContext(), BPack->getLocation(),
995 BPack->getIdentifier(), QualType());
996 NestedBD->setDecomposedDecl(DD);
997 NestedBDs[I] = NestedBD;
998 }
999
1001 S.Context.DependentTy, PackSize, /*ExpectsPackInType=*/false);
1002 auto *PackExpr = FunctionParmPackExpr::Create(
1003 S.Context, PackType, BPack, BPack->getBeginLoc(), NestedBDs);
1004 BPack->setBinding(PackType, PackExpr);
1005 }
1006
1007 if (IsValid)
1008 return false;
1009
1010 S.Diag(DD->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1011 << DecompType << (unsigned)Bindings.size() << MemberCount << MemberCount
1012 << (MemberCount < Bindings.size());
1013 return true;
1014}
1015
1018 QualType DecompType, const llvm::APSInt &NumElemsAPS, QualType ElemType,
1019 llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
1020 unsigned NumElems = (unsigned)NumElemsAPS.getLimitedValue(UINT_MAX);
1021 auto *DD = cast<DecompositionDecl>(Src);
1022
1023 if (CheckBindingsCount(S, DD, DecompType, Bindings, NumElems))
1024 return true;
1025
1026 unsigned I = 0;
1027 for (auto *B : DD->flat_bindings()) {
1028 SourceLocation Loc = B->getLocation();
1029 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1030 if (E.isInvalid())
1031 return true;
1032 E = GetInit(Loc, E.get(), I++);
1033 if (E.isInvalid())
1034 return true;
1035 B->setBinding(ElemType, E.get());
1036 }
1037
1038 return false;
1039}
1040
1043 ValueDecl *Src, QualType DecompType,
1044 const llvm::APSInt &NumElems,
1045 QualType ElemType) {
1047 S, Bindings, Src, DecompType, NumElems, ElemType,
1048 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
1050 if (E.isInvalid())
1051 return ExprError();
1052 return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
1053 });
1054}
1055
1057 ValueDecl *Src, QualType DecompType,
1058 const ConstantArrayType *CAT) {
1059 return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
1060 llvm::APSInt(CAT->getSize()),
1061 CAT->getElementType());
1062}
1063
1065 ValueDecl *Src, QualType DecompType,
1066 const VectorType *VT) {
1068 S, Bindings, Src, DecompType, llvm::APSInt::get(VT->getNumElements()),
1070 DecompType.getQualifiers()));
1071}
1072
1075 ValueDecl *Src, QualType DecompType,
1076 const ComplexType *CT) {
1078 S, Bindings, Src, DecompType, llvm::APSInt::get(2),
1080 DecompType.getQualifiers()),
1081 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
1082 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1083 });
1084}
1085
1088 const TemplateParameterList *Params) {
1090 llvm::raw_svector_ostream OS(SS);
1091 bool First = true;
1092 unsigned I = 0;
1093 for (auto &Arg : Args.arguments()) {
1094 if (!First)
1095 OS << ", ";
1096 Arg.getArgument().print(PrintingPolicy, OS,
1098 PrintingPolicy, Params, I));
1099 First = false;
1100 I++;
1101 }
1102 return std::string(OS.str());
1103}
1104
1105static QualType getStdTrait(Sema &S, SourceLocation Loc, StringRef Trait,
1106 TemplateArgumentListInfo &Args, unsigned DiagID) {
1107 auto DiagnoseMissing = [&] {
1108 if (DiagID)
1110 Args, /*Params*/ nullptr);
1111 return QualType();
1112 };
1113
1114 // FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
1116 if (!Std)
1117 return DiagnoseMissing();
1118
1119 // Look up the trait itself, within namespace std. We can diagnose various
1120 // problems with this lookup even if we've been asked to not diagnose a
1121 // missing specialization, because this can only fail if the user has been
1122 // declaring their own names in namespace std or we don't support the
1123 // standard library implementation in use.
1127 return DiagnoseMissing();
1128 if (Result.isAmbiguous())
1129 return QualType();
1130
1131 ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
1132 if (!TraitTD) {
1133 Result.suppressDiagnostics();
1134 NamedDecl *Found = *Result.begin();
1135 S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
1136 S.Diag(Found->getLocation(), diag::note_declared_at);
1137 return QualType();
1138 }
1139
1140 // Build the template-id.
1142 TemplateName(TraitTD), Loc, Args);
1143 if (TraitTy.isNull())
1144 return QualType();
1145
1146 if (!S.isCompleteType(Loc, TraitTy)) {
1147 if (DiagID)
1149 Loc, TraitTy, DiagID,
1151 TraitTD->getTemplateParameters()));
1152 return QualType();
1153 }
1154 return TraitTy;
1155}
1156
1157static bool lookupMember(Sema &S, CXXRecordDecl *RD,
1158 LookupResult &MemberLookup) {
1159 assert(RD && "specialization of class template is not a class?");
1160 S.LookupQualifiedName(MemberLookup, RD);
1161 return MemberLookup.isAmbiguous();
1162}
1163
1166 uint64_t I) {
1168 return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
1169}
1170
1174}
1175
1176namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }
1177
1179 llvm::APSInt &Size) {
1182
1183 // Form template argument list for tuple_size<T>.
1186
1187 QualType TraitTy = getStdTrait(S, Loc, "tuple_size", Args, /*DiagID=*/0);
1188 if (TraitTy.isNull())
1189 return IsTupleLike::NotTupleLike;
1190
1193
1194 // If there's no tuple_size specialization or the lookup of 'value' is empty,
1195 // it's not tuple-like.
1196 if (lookupMember(S, TraitTy->getAsCXXRecordDecl(), R) || R.empty())
1197 return IsTupleLike::NotTupleLike;
1198
1199 // If we get this far, we've committed to the tuple interpretation, but
1200 // we can still fail if there actually isn't a usable ::value.
1201
1202 struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
1203 LookupResult &R;
1205 ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
1206 : R(R), Args(Args) {}
1207 Sema::SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
1208 SourceLocation Loc) override {
1209 return S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1211 /*Params*/ nullptr);
1212 }
1213 } Diagnoser(R, Args);
1214
1215 ExprResult E =
1216 S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
1217 if (E.isInvalid())
1218 return IsTupleLike::Error;
1219
1220 E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser);
1221 if (E.isInvalid())
1222 return IsTupleLike::Error;
1223
1224 return IsTupleLike::TupleLike;
1225}
1226
1227/// \return std::tuple_element<I, T>::type.
1229 unsigned I, QualType T) {
1230 // Form template argument list for tuple_element<I, T>.
1232 Args.addArgument(
1235
1236 QualType TraitTy =
1237 getStdTrait(S, Loc, "tuple_element", Args,
1238 diag::err_decomp_decl_std_tuple_element_not_specialized);
1239 if (TraitTy.isNull())
1240 return QualType();
1241
1242 DeclarationName TypeDN = S.PP.getIdentifierInfo("type");
1244 if (lookupMember(S, TraitTy->getAsCXXRecordDecl(), R))
1245 return QualType();
1246
1247 auto *TD = R.getAsSingle<TypeDecl>();
1248 if (!TD) {
1250 S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1252 /*Params*/ nullptr);
1253 if (!R.empty())
1254 S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
1255 return QualType();
1256 }
1257
1258 NestedNameSpecifier Qualifier(TraitTy.getTypePtr());
1259 return S.Context.getTypeDeclType(ElaboratedTypeKeyword::None, Qualifier, TD);
1260}
1261
1262namespace {
1263struct InitializingBinding {
1264 Sema &S;
1265 InitializingBinding(Sema &S, BindingDecl *BD) : S(S) {
1268 Ctx.PointOfInstantiation = BD->getLocation();
1269 Ctx.Entity = BD;
1271 }
1272 ~InitializingBinding() {
1274 }
1275};
1276}
1277
1280 VarDecl *Src, QualType DecompType,
1281 const llvm::APSInt &TupleSize) {
1282 auto *DD = cast<DecompositionDecl>(Src);
1283 unsigned NumElems = (unsigned)TupleSize.getLimitedValue(UINT_MAX);
1284 if (CheckBindingsCount(S, DD, DecompType, Bindings, NumElems))
1285 return true;
1286
1287 if (Bindings.empty())
1288 return false;
1289
1290 DeclarationName GetDN = S.PP.getIdentifierInfo("get");
1291
1292 // [dcl.decomp]p3:
1293 // The unqualified-id get is looked up in the scope of E by class member
1294 // access lookup ...
1295 LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
1296 bool UseMemberGet = false;
1297 if (S.isCompleteType(Src->getLocation(), DecompType)) {
1298 if (auto *RD = DecompType->getAsCXXRecordDecl())
1299 S.LookupQualifiedName(MemberGet, RD);
1300 if (MemberGet.isAmbiguous())
1301 return true;
1302 // ... and if that finds at least one declaration that is a function
1303 // template whose first template parameter is a non-type parameter ...
1304 for (NamedDecl *D : MemberGet) {
1305 if (FunctionTemplateDecl *FTD =
1306 dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1307 TemplateParameterList *TPL = FTD->getTemplateParameters();
1308 if (TPL->size() != 0 &&
1309 isa<NonTypeTemplateParmDecl>(TPL->getParam(0))) {
1310 // ... the initializer is e.get<i>().
1311 UseMemberGet = true;
1312 break;
1313 }
1314 }
1315 }
1316 }
1317
1318 unsigned I = 0;
1319 for (auto *B : DD->flat_bindings()) {
1320 InitializingBinding InitContext(S, B);
1321 SourceLocation Loc = B->getLocation();
1322
1323 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1324 if (E.isInvalid())
1325 return true;
1326
1327 // e is an lvalue if the type of the entity is an lvalue reference and
1328 // an xvalue otherwise
1329 if (!Src->getType()->isLValueReferenceType())
1330 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
1331 E.get(), nullptr, VK_XValue,
1333
1335 Args.addArgument(
1337
1338 if (UseMemberGet) {
1339 // if [lookup of member get] finds at least one declaration, the
1340 // initializer is e.get<i-1>().
1341 E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
1342 CXXScopeSpec(), SourceLocation(), nullptr,
1343 MemberGet, &Args, nullptr);
1344 if (E.isInvalid())
1345 return true;
1346
1347 E = S.BuildCallExpr(nullptr, E.get(), Loc, {}, Loc);
1348 } else {
1349 // Otherwise, the initializer is get<i-1>(e), where get is looked up
1350 // in the associated namespaces.
1353 DeclarationNameInfo(GetDN, Loc), /*RequiresADL=*/true, &Args,
1355 /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false);
1356
1357 Expr *Arg = E.get();
1358 E = S.BuildCallExpr(nullptr, Get, Loc, Arg, Loc);
1359 }
1360 if (E.isInvalid())
1361 return true;
1362 Expr *Init = E.get();
1363
1364 // Given the type T designated by std::tuple_element<i - 1, E>::type,
1365 QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
1366 if (T.isNull())
1367 return true;
1368
1369 // each vi is a variable of type "reference to T" initialized with the
1370 // initializer, where the reference is an lvalue reference if the
1371 // initializer is an lvalue and an rvalue reference otherwise
1372 QualType RefType =
1373 S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
1374 if (RefType.isNull())
1375 return true;
1376
1377 // Don't give this VarDecl a TypeSourceInfo, since this is a synthesized
1378 // entity and this type was never written in source code.
1379 auto *RefVD =
1381 B->getDeclName().getAsIdentifierInfo(), RefType,
1382 /*TInfo=*/nullptr, Src->getStorageClass());
1383 RefVD->setLexicalDeclContext(Src->getLexicalDeclContext());
1384 RefVD->setTSCSpec(Src->getTSCSpec());
1385 RefVD->setImplicit();
1386 if (Src->isInlineSpecified())
1387 RefVD->setInlineSpecified();
1388 RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1389
1392 InitializationSequence Seq(S, Entity, Kind, Init);
1393 E = Seq.Perform(S, Entity, Kind, Init);
1394 if (E.isInvalid())
1395 return true;
1396 E = S.ActOnFinishFullExpr(E.get(), Loc, /*DiscardedValue*/ false);
1397 if (E.isInvalid())
1398 return true;
1399 RefVD->setInit(E.get());
1401
1403 DeclarationNameInfo(B->getDeclName(), Loc),
1404 RefVD);
1405 if (E.isInvalid())
1406 return true;
1407
1408 B->setBinding(T, E.get());
1409 I++;
1410 }
1411
1412 return false;
1413}
1414
1415/// Find the base class to decompose in a built-in decomposition of a class type.
1416/// This base class search is, unfortunately, not quite like any other that we
1417/// perform anywhere else in C++.
1419 const CXXRecordDecl *RD,
1420 CXXCastPath &BasePath) {
1421 auto BaseHasFields = [](const CXXBaseSpecifier *Specifier,
1422 CXXBasePath &Path) {
1423 return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1424 };
1425
1426 const CXXRecordDecl *ClassWithFields = nullptr;
1428 if (RD->hasDirectFields())
1429 // [dcl.decomp]p4:
1430 // Otherwise, all of E's non-static data members shall be public direct
1431 // members of E ...
1432 ClassWithFields = RD;
1433 else {
1434 // ... or of ...
1435 CXXBasePaths Paths;
1436 Paths.setOrigin(const_cast<CXXRecordDecl*>(RD));
1437 if (!RD->lookupInBases(BaseHasFields, Paths)) {
1438 // If no classes have fields, just decompose RD itself. (This will work
1439 // if and only if zero bindings were provided.)
1440 return DeclAccessPair::make(const_cast<CXXRecordDecl*>(RD), AS_public);
1441 }
1442
1443 CXXBasePath *BestPath = nullptr;
1444 for (auto &P : Paths) {
1445 if (!BestPath)
1446 BestPath = &P;
1447 else if (!S.Context.hasSameType(P.back().Base->getType(),
1448 BestPath->back().Base->getType())) {
1449 // ... the same ...
1450 S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1451 << false << RD << BestPath->back().Base->getType()
1452 << P.back().Base->getType();
1453 return DeclAccessPair();
1454 } else if (P.Access < BestPath->Access) {
1455 BestPath = &P;
1456 }
1457 }
1458
1459 // ... unambiguous ...
1460 QualType BaseType = BestPath->back().Base->getType();
1461 if (Paths.isAmbiguous(S.Context.getCanonicalType(BaseType))) {
1462 S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1463 << RD << BaseType << S.getAmbiguousPathsDisplayString(Paths);
1464 return DeclAccessPair();
1465 }
1466
1467 // ... [accessible, implied by other rules] base class of E.
1469 *BestPath, diag::err_decomp_decl_inaccessible_base);
1470 AS = BestPath->Access;
1471
1472 ClassWithFields = BaseType->getAsCXXRecordDecl();
1473 S.BuildBasePathArray(Paths, BasePath);
1474 }
1475
1476 // The above search did not check whether the selected class itself has base
1477 // classes with fields, so check that now.
1478 CXXBasePaths Paths;
1479 if (ClassWithFields->lookupInBases(BaseHasFields, Paths)) {
1480 S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1481 << (ClassWithFields == RD) << RD << ClassWithFields
1482 << Paths.front().back().Base->getType();
1483 return DeclAccessPair();
1484 }
1485
1486 return DeclAccessPair::make(const_cast<CXXRecordDecl*>(ClassWithFields), AS);
1487}
1488
1490 const CXXRecordDecl *OrigRD,
1491 QualType DecompType,
1492 DeclAccessPair BasePair) {
1493 const auto *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
1494 if (!RD)
1495 return true;
1496
1497 for (auto *FD : RD->fields()) {
1498 if (FD->isUnnamedBitField())
1499 continue;
1500
1501 // All the non-static data members are required to be nameable, so they
1502 // must all have names.
1503 if (!FD->getDeclName()) {
1504 if (RD->isLambda()) {
1505 S.Diag(Loc, diag::err_decomp_decl_lambda);
1506 S.Diag(RD->getLocation(), diag::note_lambda_decl);
1507 return true;
1508 }
1509
1510 if (FD->isAnonymousStructOrUnion()) {
1511 S.Diag(Loc, diag::err_decomp_decl_anon_union_member)
1512 << DecompType << FD->getType()->isUnionType();
1513 S.Diag(FD->getLocation(), diag::note_declared_at);
1514 return true;
1515 }
1516
1517 // FIXME: Are there any other ways we could have an anonymous member?
1518 }
1519 // The field must be accessible in the context of the structured binding.
1520 // We already checked that the base class is accessible.
1521 // FIXME: Add 'const' to AccessedEntity's classes so we can remove the
1522 // const_cast here.
1524 Loc, const_cast<CXXRecordDecl *>(OrigRD),
1526 BasePair.getAccess(), FD->getAccess())));
1527 }
1528 return false;
1529}
1530
1532 ValueDecl *Src, QualType DecompType,
1533 const CXXRecordDecl *OrigRD) {
1534 if (S.RequireCompleteType(Src->getLocation(), DecompType,
1535 diag::err_incomplete_type))
1536 return true;
1537
1538 CXXCastPath BasePath;
1539 DeclAccessPair BasePair =
1540 findDecomposableBaseClass(S, Src->getLocation(), OrigRD, BasePath);
1541 const auto *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
1542 if (!RD)
1543 return true;
1544 QualType BaseType = S.Context.getQualifiedType(
1545 S.Context.getCanonicalTagType(RD), DecompType.getQualifiers());
1546
1547 auto *DD = cast<DecompositionDecl>(Src);
1548 unsigned NumFields = llvm::count_if(
1549 RD->fields(), [](FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1550 if (CheckBindingsCount(S, DD, DecompType, Bindings, NumFields))
1551 return true;
1552
1553 // all of E's non-static data members shall be [...] well-formed
1554 // when named as e.name in the context of the structured binding,
1555 // E shall not have an anonymous union member, ...
1556 auto FlatBindings = DD->flat_bindings();
1557 assert(llvm::range_size(FlatBindings) == NumFields);
1558 auto FlatBindingsItr = FlatBindings.begin();
1559
1560 if (CheckMemberDecompositionFields(S, Src->getLocation(), OrigRD, DecompType,
1561 BasePair))
1562 return true;
1563
1564 for (auto *FD : RD->fields()) {
1565 if (FD->isUnnamedBitField())
1566 continue;
1567
1568 // We have a real field to bind.
1569 assert(FlatBindingsItr != FlatBindings.end());
1570 BindingDecl *B = *(FlatBindingsItr++);
1572
1573 // Initialize the binding to Src.FD.
1574 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1575 if (E.isInvalid())
1576 return true;
1577 E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
1578 VK_LValue, &BasePath);
1579 if (E.isInvalid())
1580 return true;
1581 E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
1582 CXXScopeSpec(), FD,
1583 DeclAccessPair::make(FD, FD->getAccess()),
1584 DeclarationNameInfo(FD->getDeclName(), Loc));
1585 if (E.isInvalid())
1586 return true;
1587
1588 // If the type of the member is T, the referenced type is cv T, where cv is
1589 // the cv-qualification of the decomposition expression.
1590 //
1591 // FIXME: We resolve a defect here: if the field is mutable, we do not add
1592 // 'const' to the type of the field.
1593 Qualifiers Q = DecompType.getQualifiers();
1594 if (FD->isMutable())
1595 Q.removeConst();
1596 B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
1597 }
1598
1599 return false;
1600}
1601
1603 QualType DecompType = DD->getType();
1604
1605 // If the type of the decomposition is dependent, then so is the type of
1606 // each binding.
1607 if (DecompType->isDependentType()) {
1608 // Note that all of the types are still Null or PackExpansionType.
1609 for (auto *B : DD->bindings()) {
1610 // Do not overwrite any pack type.
1611 if (B->getType().isNull())
1612 B->setType(Context.DependentTy);
1613 }
1614 return;
1615 }
1616
1617 DecompType = DecompType.getNonReferenceType();
1619
1620 // C++1z [dcl.decomp]/2:
1621 // If E is an array type [...]
1622 // As an extension, we also support decomposition of built-in complex and
1623 // vector types.
1624 if (auto *CAT = Context.getAsConstantArrayType(DecompType)) {
1625 if (checkArrayDecomposition(*this, Bindings, DD, DecompType, CAT))
1626 DD->setInvalidDecl();
1627 return;
1628 }
1629 if (auto *VT = DecompType->getAs<VectorType>()) {
1630 if (checkVectorDecomposition(*this, Bindings, DD, DecompType, VT))
1631 DD->setInvalidDecl();
1632 return;
1633 }
1634 if (auto *CT = DecompType->getAs<ComplexType>()) {
1635 if (checkComplexDecomposition(*this, Bindings, DD, DecompType, CT))
1636 DD->setInvalidDecl();
1637 return;
1638 }
1639
1640 // C++1z [dcl.decomp]/3:
1641 // if the expression std::tuple_size<E>::value is a well-formed integral
1642 // constant expression, [...]
1643 llvm::APSInt TupleSize(32);
1644 switch (isTupleLike(*this, DD->getLocation(), DecompType, TupleSize)) {
1645 case IsTupleLike::Error:
1646 DD->setInvalidDecl();
1647 return;
1648
1649 case IsTupleLike::TupleLike:
1650 if (checkTupleLikeDecomposition(*this, Bindings, DD, DecompType, TupleSize))
1651 DD->setInvalidDecl();
1652 return;
1653
1654 case IsTupleLike::NotTupleLike:
1655 break;
1656 }
1657
1658 // C++1z [dcl.dcl]/8:
1659 // [E shall be of array or non-union class type]
1660 CXXRecordDecl *RD = DecompType->getAsCXXRecordDecl();
1661 if (!RD || RD->isUnion()) {
1662 Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
1663 << DD << !RD << DecompType;
1664 DD->setInvalidDecl();
1665 return;
1666 }
1667
1668 // C++1z [dcl.decomp]/4:
1669 // all of E's non-static data members shall be [...] direct members of
1670 // E or of the same unambiguous public base class of E, ...
1671 if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
1672 DD->setInvalidDecl();
1673}
1674
1677 const ASTContext &Ctx = getASTContext();
1678 assert(!T->isDependentType());
1679
1680 Qualifiers Quals;
1681 QualType Unqual = Context.getUnqualifiedArrayType(T, Quals);
1682 Quals.removeCVRQualifiers();
1683 T = Context.getQualifiedType(Unqual, Quals);
1684
1685 if (auto *CAT = Ctx.getAsConstantArrayType(T))
1686 return static_cast<unsigned>(CAT->getSize().getZExtValue());
1687 if (auto *VT = T->getAs<VectorType>())
1688 return VT->getNumElements();
1689 if (T->getAs<ComplexType>())
1690 return 2u;
1691
1692 llvm::APSInt TupleSize(Ctx.getTypeSize(Ctx.getSizeType()));
1693 switch (isTupleLike(*this, Loc, T, TupleSize)) {
1694 case IsTupleLike::Error:
1695 return std::nullopt;
1696 case IsTupleLike::TupleLike:
1697 return static_cast<unsigned>(TupleSize.getExtValue());
1698 case IsTupleLike::NotTupleLike:
1699 break;
1700 }
1701
1702 const CXXRecordDecl *OrigRD = T->getAsCXXRecordDecl();
1703 if (!OrigRD || OrigRD->isUnion())
1704 return std::nullopt;
1705
1706 if (RequireCompleteType(Loc, T, diag::err_incomplete_type))
1707 return std::nullopt;
1708
1709 CXXCastPath BasePath;
1710 DeclAccessPair BasePair =
1711 findDecomposableBaseClass(*this, Loc, OrigRD, BasePath);
1712 const auto *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
1713 if (!RD)
1714 return std::nullopt;
1715
1716 unsigned NumFields = llvm::count_if(
1717 RD->fields(), [](FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1718
1719 if (CheckMemberDecompositionFields(*this, Loc, OrigRD, T, BasePair))
1720 return std::nullopt;
1721
1722 return NumFields;
1723}
1724
1726 // Shortcut if exceptions are disabled.
1727 if (!getLangOpts().CXXExceptions)
1728 return;
1729
1730 assert(Context.hasSameType(New->getType(), Old->getType()) &&
1731 "Should only be called if types are otherwise the same.");
1732
1733 QualType NewType = New->getType();
1734 QualType OldType = Old->getType();
1735
1736 // We're only interested in pointers and references to functions, as well
1737 // as pointers to member functions.
1738 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
1739 NewType = R->getPointeeType();
1740 OldType = OldType->castAs<ReferenceType>()->getPointeeType();
1741 } else if (const PointerType *P = NewType->getAs<PointerType>()) {
1742 NewType = P->getPointeeType();
1743 OldType = OldType->castAs<PointerType>()->getPointeeType();
1744 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
1745 NewType = M->getPointeeType();
1746 OldType = OldType->castAs<MemberPointerType>()->getPointeeType();
1747 }
1748
1749 if (!NewType->isFunctionProtoType())
1750 return;
1751
1752 // There's lots of special cases for functions. For function pointers, system
1753 // libraries are hopefully not as broken so that we don't need these
1754 // workarounds.
1756 OldType->getAs<FunctionProtoType>(), Old->getLocation(),
1757 NewType->getAs<FunctionProtoType>(), New->getLocation())) {
1758 New->setInvalidDecl();
1759 }
1760}
1761
1762/// CheckCXXDefaultArguments - Verify that the default arguments for a
1763/// function declaration are well-formed according to C++
1764/// [dcl.fct.default].
1766 // This checking doesn't make sense for explicit specializations; their
1767 // default arguments are determined by the declaration we're specializing,
1768 // not by FD.
1770 return;
1771 if (auto *FTD = FD->getDescribedFunctionTemplate())
1772 if (FTD->isMemberSpecialization())
1773 return;
1774
1775 unsigned NumParams = FD->getNumParams();
1776 unsigned ParamIdx = 0;
1777
1778 // Find first parameter with a default argument
1779 for (; ParamIdx < NumParams; ++ParamIdx) {
1780 ParmVarDecl *Param = FD->getParamDecl(ParamIdx);
1781 if (Param->hasDefaultArg())
1782 break;
1783 }
1784
1785 // C++20 [dcl.fct.default]p4:
1786 // In a given function declaration, each parameter subsequent to a parameter
1787 // with a default argument shall have a default argument supplied in this or
1788 // a previous declaration, unless the parameter was expanded from a
1789 // parameter pack, or shall be a function parameter pack.
1790 for (++ParamIdx; ParamIdx < NumParams; ++ParamIdx) {
1791 ParmVarDecl *Param = FD->getParamDecl(ParamIdx);
1792 if (Param->hasDefaultArg() || Param->isParameterPack() ||
1795 continue;
1796 if (Param->isInvalidDecl())
1797 /* We already complained about this parameter. */;
1798 else if (Param->getIdentifier())
1799 Diag(Param->getLocation(), diag::err_param_default_argument_missing_name)
1800 << Param->getIdentifier();
1801 else
1802 Diag(Param->getLocation(), diag::err_param_default_argument_missing);
1803 }
1804}
1805
1806/// Check that the given type is a literal type. Issue a diagnostic if not,
1807/// if Kind is Diagnose.
1808/// \return \c true if a problem has been found (and optionally diagnosed).
1809template <typename... Ts>
1811 SourceLocation Loc, QualType T, unsigned DiagID,
1812 Ts &&...DiagArgs) {
1813 if (T->isDependentType())
1814 return false;
1815
1816 switch (Kind) {
1818 return SemaRef.RequireLiteralType(Loc, T, DiagID,
1819 std::forward<Ts>(DiagArgs)...);
1820
1822 return !T->isLiteralType(SemaRef.Context);
1823 }
1824
1825 llvm_unreachable("unknown CheckConstexprKind");
1826}
1827
1828/// Determine whether a destructor cannot be constexpr due to
1830 const CXXDestructorDecl *DD,
1832 assert(!SemaRef.getLangOpts().CPlusPlus23 &&
1833 "this check is obsolete for C++23");
1834 auto Check = [&](SourceLocation Loc, QualType T, const FieldDecl *FD) {
1835 const CXXRecordDecl *RD =
1837 if (!RD || RD->hasConstexprDestructor())
1838 return true;
1839
1841 SemaRef.Diag(DD->getLocation(), diag::err_constexpr_dtor_subobject)
1842 << static_cast<int>(DD->getConstexprKind()) << !FD
1843 << (FD ? FD->getDeclName() : DeclarationName()) << T;
1844 SemaRef.Diag(Loc, diag::note_constexpr_dtor_subobject)
1845 << !FD << (FD ? FD->getDeclName() : DeclarationName()) << T;
1846 }
1847 return false;
1848 };
1849
1850 const CXXRecordDecl *RD = DD->getParent();
1851 for (const CXXBaseSpecifier &B : RD->bases())
1852 if (!Check(B.getBaseTypeLoc(), B.getType(), nullptr))
1853 return false;
1854 for (const FieldDecl *FD : RD->fields())
1855 if (!Check(FD->getLocation(), FD->getType(), FD))
1856 return false;
1857 return true;
1858}
1859
1860/// Check whether a function's parameter types are all literal types. If so,
1861/// return true. If not, produce a suitable diagnostic and return false.
1863 const FunctionDecl *FD,
1865 assert(!SemaRef.getLangOpts().CPlusPlus23 &&
1866 "this check is obsolete for C++23");
1867 unsigned ArgIndex = 0;
1868 const auto *FT = FD->getType()->castAs<FunctionProtoType>();
1869 for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
1870 e = FT->param_type_end();
1871 i != e; ++i, ++ArgIndex) {
1872 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
1873 assert(PD && "null in a parameter list");
1874 SourceLocation ParamLoc = PD->getLocation();
1875 if (CheckLiteralType(SemaRef, Kind, ParamLoc, *i,
1876 diag::err_constexpr_non_literal_param, ArgIndex + 1,
1877 PD->getSourceRange(), isa<CXXConstructorDecl>(FD),
1878 FD->isConsteval()))
1879 return false;
1880 }
1881 return true;
1882}
1883
1884/// Check whether a function's return type is a literal type. If so, return
1885/// true. If not, produce a suitable diagnostic and return false.
1888 assert(!SemaRef.getLangOpts().CPlusPlus23 &&
1889 "this check is obsolete for C++23");
1890 if (CheckLiteralType(SemaRef, Kind, FD->getLocation(), FD->getReturnType(),
1891 diag::err_constexpr_non_literal_return,
1892 FD->isConsteval()))
1893 return false;
1894 return true;
1895}
1896
1897/// Get diagnostic %select index for tag kind for
1898/// record diagnostic message.
1899/// WARNING: Indexes apply to particular diagnostics only!
1900///
1901/// \returns diagnostic %select index.
1903 switch (Tag) {
1905 return 0;
1907 return 1;
1908 case TagTypeKind::Class:
1909 return 2;
1910 default: llvm_unreachable("Invalid tag kind for record diagnostic!");
1911 }
1912}
1913
1914static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
1915 Stmt *Body,
1917static bool CheckConstexprMissingReturn(Sema &SemaRef, const FunctionDecl *Dcl);
1918
1920 CheckConstexprKind Kind) {
1921 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
1922 if (MD && MD->isInstance()) {
1923 // C++11 [dcl.constexpr]p4:
1924 // The definition of a constexpr constructor shall satisfy the following
1925 // constraints:
1926 // - the class shall not have any virtual base classes;
1927 //
1928 // FIXME: This only applies to constructors and destructors, not arbitrary
1929 // member functions.
1930 const CXXRecordDecl *RD = MD->getParent();
1931 if (RD->getNumVBases()) {
1933 return false;
1934
1935 Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
1936 << isa<CXXConstructorDecl>(NewFD)
1938 for (const auto &I : RD->vbases())
1939 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1940 << I.getSourceRange();
1941 return false;
1942 }
1943 }
1944
1945 if (!isa<CXXConstructorDecl>(NewFD)) {
1946 // C++11 [dcl.constexpr]p3:
1947 // The definition of a constexpr function shall satisfy the following
1948 // constraints:
1949 // - it shall not be virtual; (removed in C++20)
1950 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1951 if (Method && Method->isVirtual()) {
1952 if (getLangOpts().CPlusPlus20) {
1953 if (Kind == CheckConstexprKind::Diagnose)
1954 Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1955 } else {
1957 return false;
1958
1959 Method = Method->getCanonicalDecl();
1960 Diag(Method->getLocation(), diag::err_constexpr_virtual);
1961
1962 // If it's not obvious why this function is virtual, find an overridden
1963 // function which uses the 'virtual' keyword.
1964 const CXXMethodDecl *WrittenVirtual = Method;
1965 while (!WrittenVirtual->isVirtualAsWritten())
1966 WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
1967 if (WrittenVirtual != Method)
1968 Diag(WrittenVirtual->getLocation(),
1969 diag::note_overridden_virtual_function);
1970 return false;
1971 }
1972 }
1973
1974 // - its return type shall be a literal type; (removed in C++23)
1975 if (!getLangOpts().CPlusPlus23 &&
1976 !CheckConstexprReturnType(*this, NewFD, Kind))
1977 return false;
1978 }
1979
1980 if (auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1981 // A destructor can be constexpr only if the defaulted destructor could be;
1982 // we don't need to check the members and bases if we already know they all
1983 // have constexpr destructors. (removed in C++23)
1984 if (!getLangOpts().CPlusPlus23 &&
1985 !Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1987 return false;
1988 if (!CheckConstexprDestructorSubobjects(*this, Dtor, Kind))
1989 return false;
1990 }
1991 }
1992
1993 // - each of its parameter types shall be a literal type; (removed in C++23)
1994 if (!getLangOpts().CPlusPlus23 &&
1995 !CheckConstexprParameterTypes(*this, NewFD, Kind))
1996 return false;
1997
1998 Stmt *Body = NewFD->getBody();
1999 assert(Body &&
2000 "CheckConstexprFunctionDefinition called on function with no body");
2001 return CheckConstexprFunctionBody(*this, NewFD, Body, Kind);
2002}
2003
2004/// Check the given declaration statement is legal within a constexpr function
2005/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
2006///
2007/// \return true if the body is OK (maybe only as an extension), false if we
2008/// have diagnosed a problem.
2010 DeclStmt *DS, SourceLocation &Cxx1yLoc,
2012 // C++11 [dcl.constexpr]p3 and p4:
2013 // The definition of a constexpr function(p3) or constructor(p4) [...] shall
2014 // contain only
2015 for (const auto *DclIt : DS->decls()) {
2016 switch (DclIt->getKind()) {
2017 case Decl::StaticAssert:
2018 case Decl::Using:
2019 case Decl::UsingShadow:
2020 case Decl::UsingDirective:
2021 case Decl::UnresolvedUsingTypename:
2022 case Decl::UnresolvedUsingValue:
2023 case Decl::UsingEnum:
2024 // - static_assert-declarations
2025 // - using-declarations,
2026 // - using-directives,
2027 // - using-enum-declaration
2028 continue;
2029
2030 case Decl::Typedef:
2031 case Decl::TypeAlias: {
2032 // - typedef declarations and alias-declarations that do not define
2033 // classes or enumerations,
2034 const auto *TN = cast<TypedefNameDecl>(DclIt);
2035 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
2036 // Don't allow variably-modified types in constexpr functions.
2038 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
2039 SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
2040 << TL.getSourceRange() << TL.getType()
2041 << isa<CXXConstructorDecl>(Dcl);
2042 }
2043 return false;
2044 }
2045 continue;
2046 }
2047
2048 case Decl::Enum:
2049 case Decl::CXXRecord:
2050 // C++1y allows types to be defined, not just declared.
2051 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
2054 diag_compat::constexpr_type_definition)
2055 << isa<CXXConstructorDecl>(Dcl);
2056 } else if (!SemaRef.getLangOpts().CPlusPlus14) {
2057 return false;
2058 }
2059 }
2060 continue;
2061
2062 case Decl::EnumConstant:
2063 case Decl::IndirectField:
2064 case Decl::ParmVar:
2065 // These can only appear with other declarations which are banned in
2066 // C++11 and permitted in C++1y, so ignore them.
2067 continue;
2068
2069 case Decl::Var:
2070 case Decl::Decomposition: {
2071 // C++1y [dcl.constexpr]p3 allows anything except:
2072 // a definition of a variable of non-literal type or of static or
2073 // thread storage duration or [before C++2a] for which no
2074 // initialization is performed.
2075 const auto *VD = cast<VarDecl>(DclIt);
2076 if (VD->isThisDeclarationADefinition()) {
2077 if (VD->isStaticLocal()) {
2079 SemaRef.DiagCompat(VD->getLocation(),
2080 diag_compat::constexpr_static_var)
2081 << isa<CXXConstructorDecl>(Dcl)
2082 << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
2083 } else if (!SemaRef.getLangOpts().CPlusPlus23) {
2084 return false;
2085 }
2086 }
2087 if (SemaRef.LangOpts.CPlusPlus23) {
2088 CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(),
2089 diag::warn_cxx20_compat_constexpr_var,
2090 isa<CXXConstructorDecl>(Dcl));
2091 } else if (CheckLiteralType(
2092 SemaRef, Kind, VD->getLocation(), VD->getType(),
2093 diag::err_constexpr_local_var_non_literal_type,
2094 isa<CXXConstructorDecl>(Dcl))) {
2095 return false;
2096 }
2097 if (!VD->getType()->isDependentType() &&
2098 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
2100 SemaRef.DiagCompat(VD->getLocation(),
2101 diag_compat::constexpr_local_var_no_init)
2102 << isa<CXXConstructorDecl>(Dcl);
2103 } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2104 return false;
2105 }
2106 continue;
2107 }
2108 }
2110 SemaRef.DiagCompat(VD->getLocation(), diag_compat::constexpr_local_var)
2111 << isa<CXXConstructorDecl>(Dcl);
2112 } else if (!SemaRef.getLangOpts().CPlusPlus14) {
2113 return false;
2114 }
2115 continue;
2116 }
2117
2118 case Decl::NamespaceAlias:
2119 case Decl::Function:
2120 // These are disallowed in C++11 and permitted in C++1y. Allow them
2121 // everywhere as an extension.
2122 if (!Cxx1yLoc.isValid())
2123 Cxx1yLoc = DS->getBeginLoc();
2124 continue;
2125
2126 default:
2128 SemaRef.Diag(DS->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2129 << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
2130 }
2131 return false;
2132 }
2133 }
2134
2135 return true;
2136}
2137
2138/// Check that the given field is initialized within a constexpr constructor.
2139///
2140/// \param Dcl The constexpr constructor being checked.
2141/// \param Field The field being checked. This may be a member of an anonymous
2142/// struct or union nested within the class being checked.
2143/// \param Inits All declarations, including anonymous struct/union members and
2144/// indirect members, for which any initialization was provided.
2145/// \param Diagnosed Whether we've emitted the error message yet. Used to attach
2146/// multiple notes for different members to the same error.
2147/// \param Kind Whether we're diagnosing a constructor as written or determining
2148/// whether the formal requirements are satisfied.
2149/// \return \c false if we're checking for validity and the constructor does
2150/// not satisfy the requirements on a constexpr constructor.
2152 const FunctionDecl *Dcl,
2153 FieldDecl *Field,
2155 bool &Diagnosed,
2157 // In C++20 onwards, there's nothing to check for validity.
2159 SemaRef.getLangOpts().CPlusPlus20)
2160 return true;
2161
2162 if (Field->isInvalidDecl())
2163 return true;
2164
2165 if (Field->isUnnamedBitField())
2166 return true;
2167
2168 // Anonymous unions with no variant members and empty anonymous structs do not
2169 // need to be explicitly initialized. FIXME: Anonymous structs that contain no
2170 // indirect fields don't need initializing.
2171 if (Field->isAnonymousStructOrUnion() &&
2172 (Field->getType()->isUnionType()
2173 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
2174 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
2175 return true;
2176
2177 if (!Inits.count(Field)) {
2179 if (!Diagnosed) {
2181 diag_compat::constexpr_ctor_missing_init);
2182 Diagnosed = true;
2183 }
2184 SemaRef.Diag(Field->getLocation(),
2185 diag::note_constexpr_ctor_missing_init);
2186 } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2187 return false;
2188 }
2189 } else if (Field->isAnonymousStructOrUnion()) {
2190 const auto *RD = Field->getType()->castAsRecordDecl();
2191 for (auto *I : RD->fields())
2192 // If an anonymous union contains an anonymous struct of which any member
2193 // is initialized, all members must be initialized.
2194 if (!RD->isUnion() || Inits.count(I))
2195 if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
2196 Kind))
2197 return false;
2198 }
2199 return true;
2200}
2201
2202/// Check the provided statement is allowed in a constexpr function
2203/// definition.
2204static bool
2207 SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc,
2208 SourceLocation &Cxx2bLoc,
2210 // - its function-body shall be [...] a compound-statement that contains only
2211 switch (S->getStmtClass()) {
2212 case Stmt::NullStmtClass:
2213 // - null statements,
2214 return true;
2215
2216 case Stmt::DeclStmtClass:
2217 // - static_assert-declarations
2218 // - using-declarations,
2219 // - using-directives,
2220 // - typedef declarations and alias-declarations that do not define
2221 // classes or enumerations,
2222 if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc, Kind))
2223 return false;
2224 return true;
2225
2226 case Stmt::ReturnStmtClass:
2227 // - and exactly one return statement;
2228 if (isa<CXXConstructorDecl>(Dcl)) {
2229 // C++1y allows return statements in constexpr constructors.
2230 if (!Cxx1yLoc.isValid())
2231 Cxx1yLoc = S->getBeginLoc();
2232 return true;
2233 }
2234
2235 ReturnStmts.push_back(S->getBeginLoc());
2236 return true;
2237
2238 case Stmt::AttributedStmtClass:
2239 // Attributes on a statement don't affect its formal kind and hence don't
2240 // affect its validity in a constexpr function.
2242 SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
2243 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);
2244
2245 case Stmt::CompoundStmtClass: {
2246 // C++1y allows compound-statements.
2247 if (!Cxx1yLoc.isValid())
2248 Cxx1yLoc = S->getBeginLoc();
2249
2250 CompoundStmt *CompStmt = cast<CompoundStmt>(S);
2251 for (auto *BodyIt : CompStmt->body()) {
2252 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
2253 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2254 return false;
2255 }
2256 return true;
2257 }
2258
2259 case Stmt::IfStmtClass: {
2260 // C++1y allows if-statements.
2261 if (!Cxx1yLoc.isValid())
2262 Cxx1yLoc = S->getBeginLoc();
2263
2264 IfStmt *If = cast<IfStmt>(S);
2265 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
2266 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2267 return false;
2268 if (If->getElse() &&
2269 !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
2270 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2271 return false;
2272 return true;
2273 }
2274
2275 case Stmt::WhileStmtClass:
2276 case Stmt::DoStmtClass:
2277 case Stmt::ForStmtClass:
2278 case Stmt::CXXForRangeStmtClass:
2279 case Stmt::ContinueStmtClass:
2280 // C++1y allows all of these. We don't allow them as extensions in C++11,
2281 // because they don't make sense without variable mutation.
2282 if (!SemaRef.getLangOpts().CPlusPlus14)
2283 break;
2284 if (!Cxx1yLoc.isValid())
2285 Cxx1yLoc = S->getBeginLoc();
2286 for (Stmt *SubStmt : S->children()) {
2287 if (SubStmt &&
2288 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2289 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2290 return false;
2291 }
2292 return true;
2293
2294 case Stmt::SwitchStmtClass:
2295 case Stmt::CaseStmtClass:
2296 case Stmt::DefaultStmtClass:
2297 case Stmt::BreakStmtClass:
2298 // C++1y allows switch-statements, and since they don't need variable
2299 // mutation, we can reasonably allow them in C++11 as an extension.
2300 if (!Cxx1yLoc.isValid())
2301 Cxx1yLoc = S->getBeginLoc();
2302 for (Stmt *SubStmt : S->children()) {
2303 if (SubStmt &&
2304 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2305 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2306 return false;
2307 }
2308 return true;
2309
2310 case Stmt::LabelStmtClass:
2311 case Stmt::GotoStmtClass:
2312 if (Cxx2bLoc.isInvalid())
2313 Cxx2bLoc = S->getBeginLoc();
2314 for (Stmt *SubStmt : S->children()) {
2315 if (SubStmt &&
2316 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2317 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2318 return false;
2319 }
2320 return true;
2321
2322 case Stmt::GCCAsmStmtClass:
2323 case Stmt::MSAsmStmtClass:
2324 // C++2a allows inline assembly statements.
2325 case Stmt::CXXTryStmtClass:
2326 if (Cxx2aLoc.isInvalid())
2327 Cxx2aLoc = S->getBeginLoc();
2328 for (Stmt *SubStmt : S->children()) {
2329 if (SubStmt &&
2330 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2331 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2332 return false;
2333 }
2334 return true;
2335
2336 case Stmt::CXXCatchStmtClass:
2337 // Do not bother checking the language mode (already covered by the
2338 // try block check).
2340 SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
2341 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2342 return false;
2343 return true;
2344
2345 default:
2346 if (!isa<Expr>(S))
2347 break;
2348
2349 // C++1y allows expression-statements.
2350 if (!Cxx1yLoc.isValid())
2351 Cxx1yLoc = S->getBeginLoc();
2352 return true;
2353 }
2354
2356 SemaRef.Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2357 << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
2358 }
2359 return false;
2360}
2361
2362/// Check the body for the given constexpr function declaration only contains
2363/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
2364///
2365/// \return true if the body is OK, false if we have found or diagnosed a
2366/// problem.
2368 Stmt *Body,
2371
2372 if (isa<CXXTryStmt>(Body)) {
2373 // C++11 [dcl.constexpr]p3:
2374 // The definition of a constexpr function shall satisfy the following
2375 // constraints: [...]
2376 // - its function-body shall be = delete, = default, or a
2377 // compound-statement
2378 //
2379 // C++11 [dcl.constexpr]p4:
2380 // In the definition of a constexpr constructor, [...]
2381 // - its function-body shall not be a function-try-block;
2382 //
2383 // This restriction is lifted in C++2a, as long as inner statements also
2384 // apply the general constexpr rules.
2385 switch (Kind) {
2387 if (!SemaRef.getLangOpts().CPlusPlus20)
2388 return false;
2389 break;
2390
2393 diag_compat::constexpr_function_try_block)
2394 << isa<CXXConstructorDecl>(Dcl);
2395 break;
2396 }
2397 }
2398
2399 // - its function-body shall be [...] a compound-statement that contains only
2400 // [... list of cases ...]
2401 //
2402 // Note that walking the children here is enough to properly check for
2403 // CompoundStmt and CXXTryStmt body.
2404 SourceLocation Cxx1yLoc, Cxx2aLoc, Cxx2bLoc;
2405 for (Stmt *SubStmt : Body->children()) {
2406 if (SubStmt &&
2407 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2408 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2409 return false;
2410 }
2411
2413 // If this is only valid as an extension, report that we don't satisfy the
2414 // constraints of the current language.
2415 if ((Cxx2bLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus23) ||
2416 (Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) ||
2417 (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
2418 return false;
2419 } else if (Cxx2bLoc.isValid()) {
2420 SemaRef.DiagCompat(Cxx2bLoc, diag_compat::cxx23_constexpr_body_invalid_stmt)
2421 << isa<CXXConstructorDecl>(Dcl);
2422 } else if (Cxx2aLoc.isValid()) {
2423 SemaRef.DiagCompat(Cxx2aLoc, diag_compat::cxx20_constexpr_body_invalid_stmt)
2424 << isa<CXXConstructorDecl>(Dcl);
2425 } else if (Cxx1yLoc.isValid()) {
2426 SemaRef.DiagCompat(Cxx1yLoc, diag_compat::cxx14_constexpr_body_invalid_stmt)
2427 << isa<CXXConstructorDecl>(Dcl);
2428 }
2429
2431 = dyn_cast<CXXConstructorDecl>(Dcl)) {
2432 const CXXRecordDecl *RD = Constructor->getParent();
2433 // DR1359:
2434 // - every non-variant non-static data member and base class sub-object
2435 // shall be initialized;
2436 // DR1460:
2437 // - if the class is a union having variant members, exactly one of them
2438 // shall be initialized;
2439 if (RD->isUnion()) {
2440 if (Constructor->getNumCtorInitializers() == 0 &&
2441 RD->hasVariantMembers()) {
2444 diag_compat::constexpr_union_ctor_no_init);
2445 } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2446 return false;
2447 }
2448 }
2449 } else if (!Constructor->isDependentContext() &&
2450 !Constructor->isDelegatingConstructor()) {
2451 assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
2452
2453 // Skip detailed checking if we have enough initializers, and we would
2454 // allow at most one initializer per member.
2455 bool AnyAnonStructUnionMembers = false;
2456 unsigned Fields = 0;
2458 E = RD->field_end(); I != E; ++I, ++Fields) {
2459 if (I->isAnonymousStructOrUnion()) {
2460 AnyAnonStructUnionMembers = true;
2461 break;
2462 }
2463 }
2464 // DR1460:
2465 // - if the class is a union-like class, but is not a union, for each of
2466 // its anonymous union members having variant members, exactly one of
2467 // them shall be initialized;
2468 if (AnyAnonStructUnionMembers ||
2469 Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
2470 // Check initialization of non-static data members. Base classes are
2471 // always initialized so do not need to be checked. Dependent bases
2472 // might not have initializers in the member initializer list.
2474 for (const auto *I: Constructor->inits()) {
2475 if (FieldDecl *FD = I->getMember())
2476 Inits.insert(FD);
2477 else if (IndirectFieldDecl *ID = I->getIndirectMember())
2478 Inits.insert(ID->chain_begin(), ID->chain_end());
2479 }
2480
2481 bool Diagnosed = false;
2482 for (auto *I : RD->fields())
2483 if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
2484 Kind))
2485 return false;
2486 }
2487 }
2488 } else {
2489 if (ReturnStmts.empty()) {
2490 switch (Kind) {
2493 return false;
2494 break;
2495
2497 // The formal requirements don't include this rule in C++14, even
2498 // though the "must be able to produce a constant expression" rules
2499 // still imply it in some cases.
2500 if (!SemaRef.getLangOpts().CPlusPlus14)
2501 return false;
2502 break;
2503 }
2504 } else if (ReturnStmts.size() > 1) {
2505 switch (Kind) {
2507 SemaRef.DiagCompat(ReturnStmts.back(),
2508 diag_compat::constexpr_body_multiple_return);
2509 for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2510 SemaRef.Diag(ReturnStmts[I],
2511 diag::note_constexpr_body_previous_return);
2512 break;
2513
2515 if (!SemaRef.getLangOpts().CPlusPlus14)
2516 return false;
2517 break;
2518 }
2519 }
2520 }
2521
2522 // C++11 [dcl.constexpr]p5:
2523 // if no function argument values exist such that the function invocation
2524 // substitution would produce a constant expression, the program is
2525 // ill-formed; no diagnostic required.
2526 // C++11 [dcl.constexpr]p3:
2527 // - every constructor call and implicit conversion used in initializing the
2528 // return value shall be one of those allowed in a constant expression.
2529 // C++11 [dcl.constexpr]p4:
2530 // - every constructor involved in initializing non-static data members and
2531 // base class sub-objects shall be a constexpr constructor.
2532 //
2533 // Note that this rule is distinct from the "requirements for a constexpr
2534 // function", so is not checked in CheckValid mode. Because the check for
2535 // constexpr potential is expensive, skip the check if the diagnostic is
2536 // disabled, the function is declared in a system header, or we're in C++23
2537 // or later mode (see https://wg21.link/P2448).
2538 bool SkipCheck =
2539 !SemaRef.getLangOpts().CheckConstexprFunctionBodies ||
2542 diag::ext_constexpr_function_never_constant_expr, Dcl->getLocation());
2544 if (Kind == Sema::CheckConstexprKind::Diagnose && !SkipCheck &&
2546 SemaRef.Diag(Dcl->getLocation(),
2547 diag::ext_constexpr_function_never_constant_expr)
2548 << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval()
2549 << Dcl->getNameInfo().getSourceRange();
2550 for (size_t I = 0, N = Diags.size(); I != N; ++I)
2551 SemaRef.Diag(Diags[I].first, Diags[I].second);
2552 // Don't return false here: we allow this for compatibility in
2553 // system headers.
2554 }
2555
2556 return true;
2557}
2558
2560 const FunctionDecl *Dcl) {
2561 bool IsVoidOrDependentType = Dcl->getReturnType()->isVoidType() ||
2563 // Skip emitting a missing return error diagnostic for non-void functions
2564 // since C++23 no longer mandates constexpr functions to yield constant
2565 // expressions.
2566 if (SemaRef.getLangOpts().CPlusPlus23 && !IsVoidOrDependentType)
2567 return true;
2568
2569 // C++14 doesn't require constexpr functions to contain a 'return'
2570 // statement. We still do, unless the return type might be void, because
2571 // otherwise if there's no return statement, the function cannot
2572 // be used in a core constant expression.
2573 bool OK = SemaRef.getLangOpts().CPlusPlus14 && IsVoidOrDependentType;
2574 SemaRef.Diag(Dcl->getLocation(),
2575 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2576 : diag::err_constexpr_body_no_return)
2577 << Dcl->isConsteval();
2578 return OK;
2579}
2580
2582 FunctionDecl *FD, const sema::FunctionScopeInfo *FSI) {
2584 return true;
2588 auto it = UndefinedButUsed.find(FD->getCanonicalDecl());
2589 if (it != UndefinedButUsed.end()) {
2590 Diag(it->second, diag::err_immediate_function_used_before_definition)
2591 << it->first;
2592 Diag(FD->getLocation(), diag::note_defined_here) << FD;
2593 if (FD->isImmediateFunction() && !FD->isConsteval())
2595 return false;
2596 }
2597 }
2598 return true;
2599}
2600
2602 assert(FD->isImmediateEscalating() && !FD->isConsteval() &&
2603 "expected an immediate function");
2604 assert(FD->hasBody() && "expected the function to have a body");
2605 struct ImmediateEscalatingExpressionsVisitor : DynamicRecursiveASTVisitor {
2606 Sema &SemaRef;
2607
2608 const FunctionDecl *ImmediateFn;
2609 bool ImmediateFnIsConstructor;
2610 CXXConstructorDecl *CurrentConstructor = nullptr;
2611 CXXCtorInitializer *CurrentInit = nullptr;
2612
2613 ImmediateEscalatingExpressionsVisitor(Sema &SemaRef, FunctionDecl *FD)
2614 : SemaRef(SemaRef), ImmediateFn(FD),
2615 ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {
2616 ShouldVisitImplicitCode = true;
2617 ShouldVisitLambdaBody = false;
2618 }
2619
2620 void Diag(const Expr *E, const FunctionDecl *Fn, bool IsCall) {
2623 if (CurrentConstructor && CurrentInit) {
2624 Loc = CurrentConstructor->getLocation();
2625 Range = CurrentInit->isWritten() ? CurrentInit->getSourceRange()
2626 : SourceRange();
2627 }
2628
2629 FieldDecl* InitializedField = CurrentInit ? CurrentInit->getAnyMember() : nullptr;
2630
2631 SemaRef.Diag(Loc, diag::note_immediate_function_reason)
2632 << ImmediateFn << Fn << Fn->isConsteval() << IsCall
2633 << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
2634 << (InitializedField != nullptr)
2635 << (CurrentInit && !CurrentInit->isWritten())
2636 << InitializedField << Range;
2637 }
2638 bool TraverseCallExpr(CallExpr *E) override {
2639 if (const auto *DR =
2640 dyn_cast<DeclRefExpr>(E->getCallee()->IgnoreImplicit());
2641 DR && DR->isImmediateEscalating()) {
2642 Diag(E, E->getDirectCallee(), /*IsCall=*/true);
2643 return false;
2644 }
2645
2646 for (Expr *A : E->arguments())
2647 if (!TraverseStmt(A))
2648 return false;
2649
2650 return true;
2651 }
2652
2653 bool VisitDeclRefExpr(DeclRefExpr *E) override {
2654 if (const auto *ReferencedFn = dyn_cast<FunctionDecl>(E->getDecl());
2655 ReferencedFn && E->isImmediateEscalating()) {
2656 Diag(E, ReferencedFn, /*IsCall=*/false);
2657 return false;
2658 }
2659
2660 return true;
2661 }
2662
2663 bool VisitCXXConstructExpr(CXXConstructExpr *E) override {
2664 CXXConstructorDecl *D = E->getConstructor();
2665 if (E->isImmediateEscalating()) {
2666 Diag(E, D, /*IsCall=*/true);
2667 return false;
2668 }
2669 return true;
2670 }
2671
2672 bool TraverseConstructorInitializer(CXXCtorInitializer *Init) override {
2673 llvm::SaveAndRestore RAII(CurrentInit, Init);
2675 }
2676
2677 bool TraverseCXXConstructorDecl(CXXConstructorDecl *Ctr) override {
2678 llvm::SaveAndRestore RAII(CurrentConstructor, Ctr);
2679 return DynamicRecursiveASTVisitor::TraverseCXXConstructorDecl(Ctr);
2680 }
2681
2682 bool TraverseType(QualType T, bool TraverseQualifier) override {
2683 return true;
2684 }
2685 bool VisitBlockExpr(BlockExpr *T) override { return true; }
2686
2687 } Visitor(*this, FD);
2688 Visitor.TraverseDecl(FD);
2689}
2690
2692 assert(getLangOpts().CPlusPlus && "No class names in C!");
2693
2694 if (SS && SS->isInvalid())
2695 return nullptr;
2696
2697 if (SS && SS->isNotEmpty()) {
2698 DeclContext *DC = computeDeclContext(*SS, true);
2699 return dyn_cast_or_null<CXXRecordDecl>(DC);
2700 }
2701
2702 return dyn_cast_or_null<CXXRecordDecl>(CurContext);
2703}
2704
2706 const CXXScopeSpec *SS) {
2707 CXXRecordDecl *CurDecl = getCurrentClass(S, SS);
2708 return CurDecl && &II == CurDecl->getIdentifier();
2709}
2710
2712 assert(getLangOpts().CPlusPlus && "No class names in C!");
2713
2714 if (!getLangOpts().SpellChecking)
2715 return false;
2716
2717 CXXRecordDecl *CurDecl;
2718 if (SS && SS->isSet() && !SS->isInvalid()) {
2719 DeclContext *DC = computeDeclContext(*SS, true);
2720 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2721 } else
2722 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
2723
2724 if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
2725 3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
2726 < II->getLength()) {
2727 II = CurDecl->getIdentifier();
2728 return true;
2729 }
2730
2731 return false;
2732}
2733
2735 SourceRange SpecifierRange,
2736 bool Virtual, AccessSpecifier Access,
2737 TypeSourceInfo *TInfo,
2738 SourceLocation EllipsisLoc) {
2739 QualType BaseType = TInfo->getType();
2740 SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
2741 if (BaseType->containsErrors()) {
2742 // Already emitted a diagnostic when parsing the error type.
2743 return nullptr;
2744 }
2745
2746 if (EllipsisLoc.isValid() && !BaseType->containsUnexpandedParameterPack()) {
2747 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2748 << TInfo->getTypeLoc().getSourceRange();
2749 EllipsisLoc = SourceLocation();
2750 }
2751
2752 auto *BaseDecl =
2753 dyn_cast_if_present<CXXRecordDecl>(computeDeclContext(BaseType));
2754 // C++ [class.derived.general]p2:
2755 // A class-or-decltype shall denote a (possibly cv-qualified) class type
2756 // that is not an incompletely defined class; any cv-qualifiers are
2757 // ignored.
2758 if (BaseDecl) {
2759 // C++ [class.union.general]p4:
2760 // [...] A union shall not be used as a base class.
2761 if (BaseDecl->isUnion()) {
2762 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2763 return nullptr;
2764 }
2765
2766 if (BaseType.hasQualifiers()) {
2767 std::string Quals =
2769 Diag(BaseLoc, diag::warn_qual_base_type)
2770 << Quals << llvm::count(Quals, ' ') + 1 << BaseType;
2771 Diag(BaseLoc, diag::note_base_class_specified_here) << BaseType;
2772 }
2773
2774 // For the MS ABI, propagate DLL attributes to base class templates.
2776 Context.getTargetInfo().getTriple().isPS()) {
2777 if (Attr *ClassAttr = getDLLAttr(Class)) {
2778 if (auto *BaseSpec =
2779 dyn_cast<ClassTemplateSpecializationDecl>(BaseDecl)) {
2780 propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseSpec,
2781 BaseLoc);
2782 }
2783 }
2784 }
2785
2786 if (RequireCompleteType(BaseLoc, BaseType, diag::err_incomplete_base_class,
2787 SpecifierRange)) {
2788 Class->setInvalidDecl();
2789 return nullptr;
2790 }
2791
2792 BaseDecl = BaseDecl->getDefinition();
2793 assert(BaseDecl && "Base type is not incomplete, but has no definition");
2794
2795 // Microsoft docs say:
2796 // "If a base-class has a code_seg attribute, derived classes must have the
2797 // same attribute."
2798 const auto *BaseCSA = BaseDecl->getAttr<CodeSegAttr>();
2799 const auto *DerivedCSA = Class->getAttr<CodeSegAttr>();
2800 if ((DerivedCSA || BaseCSA) &&
2801 (!BaseCSA || !DerivedCSA ||
2802 BaseCSA->getName() != DerivedCSA->getName())) {
2803 Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
2804 Diag(BaseDecl->getLocation(), diag::note_base_class_specified_here)
2805 << BaseDecl;
2806 return nullptr;
2807 }
2808
2809 // A class which contains a flexible array member is not suitable for use as
2810 // a base class:
2811 // - If the layout determines that a base comes before another base,
2812 // the flexible array member would index into the subsequent base.
2813 // - If the layout determines that base comes before the derived class,
2814 // the flexible array member would index into the derived class.
2815 if (BaseDecl->hasFlexibleArrayMember()) {
2816 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2817 << BaseDecl->getDeclName();
2818 return nullptr;
2819 }
2820
2821 // C++ [class]p3:
2822 // If a class is marked final and it appears as a base-type-specifier in
2823 // base-clause, the program is ill-formed.
2824 if (FinalAttr *FA = BaseDecl->getAttr<FinalAttr>()) {
2825 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2826 << BaseDecl->getDeclName() << FA->isSpelledAsSealed();
2827 Diag(BaseDecl->getLocation(), diag::note_entity_declared_at)
2828 << BaseDecl->getDeclName() << FA->getRange();
2829 return nullptr;
2830 }
2831
2832 // If the base class is invalid the derived class is as well.
2833 if (BaseDecl->isInvalidDecl())
2834 Class->setInvalidDecl();
2835 } else if (BaseType->isDependentType()) {
2836 // Make sure that we don't make an ill-formed AST where the type of the
2837 // Class is non-dependent and its attached base class specifier is an
2838 // dependent type, which violates invariants in many clang code paths (e.g.
2839 // constexpr evaluator). If this case happens (in errory-recovery mode), we
2840 // explicitly mark the Class decl invalid. The diagnostic was already
2841 // emitted.
2842 if (!Class->isDependentContext())
2843 Class->setInvalidDecl();
2844 } else {
2845 // The base class is some non-dependent non-class type.
2846 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2847 return nullptr;
2848 }
2849
2850 // In HLSL, unspecified class access is public rather than private.
2851 if (getLangOpts().HLSL && Class->getTagKind() == TagTypeKind::Class &&
2852 Access == AS_none)
2853 Access = AS_public;
2854
2855 // Create the base specifier.
2856 return new (Context) CXXBaseSpecifier(
2857 SpecifierRange, Virtual, Class->getTagKind() == TagTypeKind::Class,
2858 Access, TInfo, EllipsisLoc);
2859}
2860
2862 const ParsedAttributesView &Attributes,
2863 bool Virtual, AccessSpecifier Access,
2864 ParsedType basetype, SourceLocation BaseLoc,
2865 SourceLocation EllipsisLoc) {
2866 if (!classdecl)
2867 return true;
2868
2869 AdjustDeclIfTemplate(classdecl);
2870 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
2871 if (!Class)
2872 return true;
2873
2874 // We haven't yet attached the base specifiers.
2875 Class->setIsParsingBaseSpecifiers();
2876
2877 // We do not support any C++11 attributes on base-specifiers yet.
2878 // Diagnose any attributes we see.
2879 for (const ParsedAttr &AL : Attributes) {
2880 if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
2881 continue;
2882 if (AL.getKind() == ParsedAttr::UnknownAttribute)
2884 else
2885 Diag(AL.getLoc(), diag::err_base_specifier_attribute)
2886 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2887 }
2888
2889 TypeSourceInfo *TInfo = nullptr;
2890 GetTypeFromParser(basetype, &TInfo);
2891
2892 if (EllipsisLoc.isInvalid() &&
2893 DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
2895 return true;
2896
2897 // C++ [class.union.general]p4:
2898 // [...] A union shall not have base classes.
2899 if (Class->isUnion()) {
2900 Diag(Class->getLocation(), diag::err_base_clause_on_union)
2901 << SpecifierRange;
2902 return true;
2903 }
2904
2905 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
2906 Virtual, Access, TInfo,
2907 EllipsisLoc))
2908 return BaseSpec;
2909
2910 Class->setInvalidDecl();
2911 return true;
2912}
2913
2914/// Use small set to collect indirect bases. As this is only used
2915/// locally, there's no need to abstract the small size parameter.
2917
2918/// Recursively add the bases of Type. Don't add Type itself.
2919static void
2921 const QualType &Type)
2922{
2923 // Even though the incoming type is a base, it might not be
2924 // a class -- it could be a template parm, for instance.
2925 if (const auto *Decl = Type->getAsCXXRecordDecl()) {
2926 // Iterate over its bases.
2927 for (const auto &BaseSpec : Decl->bases()) {
2928 QualType Base = Context.getCanonicalType(BaseSpec.getType())
2930 if (Set.insert(Base).second)
2931 // If we've not already seen it, recurse.
2933 }
2934 }
2935}
2936
2939 if (Bases.empty())
2940 return false;
2941
2942 // Used to keep track of which base types we have already seen, so
2943 // that we can properly diagnose redundant direct base types. Note
2944 // that the key is always the unqualified canonical type of the base
2945 // class.
2946 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2947
2948 // Used to track indirect bases so we can see if a direct base is
2949 // ambiguous.
2950 IndirectBaseSet IndirectBaseTypes;
2951
2952 // Copy non-redundant base specifiers into permanent storage.
2953 unsigned NumGoodBases = 0;
2954 bool Invalid = false;
2955 for (unsigned idx = 0; idx < Bases.size(); ++idx) {
2956 QualType NewBaseType
2957 = Context.getCanonicalType(Bases[idx]->getType());
2958 NewBaseType = NewBaseType.getLocalUnqualifiedType();
2959
2960 CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
2961 if (KnownBase) {
2962 // C++ [class.mi]p3:
2963 // A class shall not be specified as a direct base class of a
2964 // derived class more than once.
2965 Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2966 << KnownBase->getType() << Bases[idx]->getSourceRange();
2967
2968 // Delete the duplicate base class specifier; we're going to
2969 // overwrite its pointer later.
2970 Context.Deallocate(Bases[idx]);
2971
2972 Invalid = true;
2973 } else {
2974 // Okay, add this new base class.
2975 KnownBase = Bases[idx];
2976 Bases[NumGoodBases++] = Bases[idx];
2977
2978 if (NewBaseType->isDependentType())
2979 continue;
2980 // Note this base's direct & indirect bases, if there could be ambiguity.
2981 if (Bases.size() > 1)
2982 NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
2983
2984 if (const auto *RD = NewBaseType->getAsCXXRecordDecl()) {
2985 if (Class->isInterface() &&
2986 (!RD->isInterfaceLike() ||
2987 KnownBase->getAccessSpecifier() != AS_public)) {
2988 // The Microsoft extension __interface does not permit bases that
2989 // are not themselves public interfaces.
2990 Diag(KnownBase->getBeginLoc(), diag::err_invalid_base_in_interface)
2991 << getRecordDiagFromTagKind(RD->getTagKind()) << RD
2992 << RD->getSourceRange();
2993 Invalid = true;
2994 }
2995 if (RD->hasAttr<WeakAttr>())
2996 Class->addAttr(WeakAttr::CreateImplicit(Context));
2997 }
2998 }
2999 }
3000
3001 // Attach the remaining base class specifiers to the derived class.
3002 Class->setBases(Bases.data(), NumGoodBases);
3003
3004 // Check that the only base classes that are duplicate are virtual.
3005 for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
3006 // Check whether this direct base is inaccessible due to ambiguity.
3007 QualType BaseType = Bases[idx]->getType();
3008
3009 // Skip all dependent types in templates being used as base specifiers.
3010 // Checks below assume that the base specifier is a CXXRecord.
3011 if (BaseType->isDependentType())
3012 continue;
3013
3014 CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
3016
3017 if (IndirectBaseTypes.count(CanonicalBase)) {
3018 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3019 /*DetectVirtual=*/true);
3020 bool found
3021 = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
3022 assert(found);
3023 (void)found;
3024
3025 if (Paths.isAmbiguous(CanonicalBase))
3026 Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
3027 << BaseType << getAmbiguousPathsDisplayString(Paths)
3028 << Bases[idx]->getSourceRange();
3029 else
3030 assert(Bases[idx]->isVirtual());
3031 }
3032
3033 // Delete the base class specifier, since its data has been copied
3034 // into the CXXRecordDecl.
3035 Context.Deallocate(Bases[idx]);
3036 }
3037
3038 return Invalid;
3039}
3040
3043 if (!ClassDecl || Bases.empty())
3044 return;
3045
3046 AdjustDeclIfTemplate(ClassDecl);
3047 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
3048}
3049
3051 CXXRecordDecl *Base, CXXBasePaths &Paths) {
3052 if (!getLangOpts().CPlusPlus)
3053 return false;
3054
3055 if (!Base || !Derived)
3056 return false;
3057
3058 // If either the base or the derived type is invalid, don't try to
3059 // check whether one is derived from the other.
3060 if (Base->isInvalidDecl() || Derived->isInvalidDecl())
3061 return false;
3062
3063 // FIXME: In a modules build, do we need the entire path to be visible for us
3064 // to be able to use the inheritance relationship?
3066 !Derived->isBeingDefined())
3067 return false;
3068
3069 return Derived->isDerivedFrom(Base, Paths);
3070}
3071
3074 CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
3075 /*DetectVirtual=*/false);
3076 return IsDerivedFrom(Loc, Derived, Base, Paths);
3077}
3078
3080 CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
3081 /*DetectVirtual=*/false);
3082 return IsDerivedFrom(Loc, Derived->getAsCXXRecordDecl(),
3083 Base->getAsCXXRecordDecl(), Paths);
3084}
3085
3087 CXXBasePaths &Paths) {
3088 return IsDerivedFrom(Loc, Derived->getAsCXXRecordDecl(),
3089 Base->getAsCXXRecordDecl(), Paths);
3090}
3091
3093 CXXCastPath &BasePathArray) {
3094 // We first go backward and check if we have a virtual base.
3095 // FIXME: It would be better if CXXBasePath had the base specifier for
3096 // the nearest virtual base.
3097 unsigned Start = 0;
3098 for (unsigned I = Path.size(); I != 0; --I) {
3099 if (Path[I - 1].Base->isVirtual()) {
3100 Start = I - 1;
3101 break;
3102 }
3103 }
3104
3105 // Now add all bases.
3106 for (unsigned I = Start, E = Path.size(); I != E; ++I)
3107 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
3108}
3109
3110
3112 CXXCastPath &BasePathArray) {
3113 assert(BasePathArray.empty() && "Base path array must be empty!");
3114 assert(Paths.isRecordingPaths() && "Must record paths!");
3115 return ::BuildBasePathArray(Paths.front(), BasePathArray);
3116}
3117
3118bool
3120 unsigned InaccessibleBaseID,
3121 unsigned AmbiguousBaseConvID,
3123 DeclarationName Name,
3124 CXXCastPath *BasePath,
3125 bool IgnoreAccess) {
3126 // First, determine whether the path from Derived to Base is
3127 // ambiguous. This is slightly more expensive than checking whether
3128 // the Derived to Base conversion exists, because here we need to
3129 // explore multiple paths to determine if there is an ambiguity.
3130 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3131 /*DetectVirtual=*/false);
3132 bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
3133 if (!DerivationOkay)
3134 return true;
3135
3136 const CXXBasePath *Path = nullptr;
3137 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
3138 Path = &Paths.front();
3139
3140 // For MSVC compatibility, check if Derived directly inherits from Base. Clang
3141 // warns about this hierarchy under -Winaccessible-base, but MSVC allows the
3142 // user to access such bases.
3143 if (!Path && getLangOpts().MSVCCompat) {
3144 for (const CXXBasePath &PossiblePath : Paths) {
3145 if (PossiblePath.size() == 1) {
3146 Path = &PossiblePath;
3147 if (AmbiguousBaseConvID)
3148 Diag(Loc, diag::ext_ms_ambiguous_direct_base)
3149 << Base << Derived << Range;
3150 break;
3151 }
3152 }
3153 }
3154
3155 if (Path) {
3156 if (!IgnoreAccess) {
3157 // Check that the base class can be accessed.
3158 switch (
3159 CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
3160 case AR_inaccessible:
3161 return true;
3162 case AR_accessible:
3163 case AR_dependent:
3164 case AR_delayed:
3165 break;
3166 }
3167 }
3168
3169 // Build a base path if necessary.
3170 if (BasePath)
3171 ::BuildBasePathArray(*Path, *BasePath);
3172 return false;
3173 }
3174
3175 if (AmbiguousBaseConvID) {
3176 // We know that the derived-to-base conversion is ambiguous, and
3177 // we're going to produce a diagnostic. Perform the derived-to-base
3178 // search just one more time to compute all of the possible paths so
3179 // that we can print them out. This is more expensive than any of
3180 // the previous derived-to-base checks we've done, but at this point
3181 // performance isn't as much of an issue.
3182 Paths.clear();
3183 Paths.setRecordingPaths(true);
3184 bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
3185 assert(StillOkay && "Can only be used with a derived-to-base conversion");
3186 (void)StillOkay;
3187
3188 // Build up a textual representation of the ambiguous paths, e.g.,
3189 // D -> B -> A, that will be used to illustrate the ambiguous
3190 // conversions in the diagnostic. We only print one of the paths
3191 // to each base class subobject.
3192 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3193
3194 Diag(Loc, AmbiguousBaseConvID)
3195 << Derived << Base << PathDisplayStr << Range << Name;
3196 }
3197 return true;
3198}
3199
3200bool
3203 CXXCastPath *BasePath,
3204 bool IgnoreAccess) {
3206 Derived, Base, diag::err_upcast_to_inaccessible_base,
3207 diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
3208 BasePath, IgnoreAccess);
3209}
3210
3212 std::string PathDisplayStr;
3213 std::set<unsigned> DisplayedPaths;
3214 for (CXXBasePaths::paths_iterator Path = Paths.begin();
3215 Path != Paths.end(); ++Path) {
3216 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
3217 // We haven't displayed a path to this particular base
3218 // class subobject yet.
3219 PathDisplayStr += "\n ";
3220 PathDisplayStr += QualType(Context.getCanonicalTagType(Paths.getOrigin()))
3221 .getAsString();
3222 for (CXXBasePath::const_iterator Element = Path->begin();
3223 Element != Path->end(); ++Element)
3224 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
3225 }
3226 }
3227
3228 return PathDisplayStr;
3229}
3230
3231//===----------------------------------------------------------------------===//
3232// C++ class member Handling
3233//===----------------------------------------------------------------------===//
3234
3236 SourceLocation ColonLoc,
3237 const ParsedAttributesView &Attrs) {
3238 assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
3240 ASLoc, ColonLoc);
3241 CurContext->addHiddenDecl(ASDecl);
3242 return ProcessAccessDeclAttributeList(ASDecl, Attrs);
3243}
3244
3246 if (D->isInvalidDecl())
3247 return;
3248
3249 // We only care about "override" and "final" declarations.
3250 if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
3251 return;
3252
3253 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
3254
3255 // We can't check dependent instance methods.
3256 if (MD && MD->isInstance() &&
3257 (MD->getParent()->hasAnyDependentBases() ||
3258 MD->getType()->isDependentType()))
3259 return;
3260
3261 if (MD && !MD->isVirtual()) {
3262 // If we have a non-virtual method, check if it hides a virtual method.
3263 // (In that case, it's most likely the method has the wrong type.)
3264 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
3265 FindHiddenVirtualMethods(MD, OverloadedMethods);
3266
3267 if (!OverloadedMethods.empty()) {
3268 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3269 Diag(OA->getLocation(),
3270 diag::override_keyword_hides_virtual_member_function)
3271 << "override" << (OverloadedMethods.size() > 1);
3272 } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3273 Diag(FA->getLocation(),
3274 diag::override_keyword_hides_virtual_member_function)
3275 << (FA->isSpelledAsSealed() ? "sealed" : "final")
3276 << (OverloadedMethods.size() > 1);
3277 }
3278 NoteHiddenVirtualMethods(MD, OverloadedMethods);
3279 MD->setInvalidDecl();
3280 return;
3281 }
3282 // Fall through into the general case diagnostic.
3283 // FIXME: We might want to attempt typo correction here.
3284 }
3285
3286 if (!MD || !MD->isVirtual()) {
3287 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3288 Diag(OA->getLocation(),
3289 diag::override_keyword_only_allowed_on_virtual_member_functions)
3290 << "override" << FixItHint::CreateRemoval(OA->getLocation());
3291 D->dropAttr<OverrideAttr>();
3292 }
3293 if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3294 Diag(FA->getLocation(),
3295 diag::override_keyword_only_allowed_on_virtual_member_functions)
3296 << (FA->isSpelledAsSealed() ? "sealed" : "final")
3297 << FixItHint::CreateRemoval(FA->getLocation());
3298 D->dropAttr<FinalAttr>();
3299 }
3300 return;
3301 }
3302
3303 // C++11 [class.virtual]p5:
3304 // If a function is marked with the virt-specifier override and
3305 // does not override a member function of a base class, the program is
3306 // ill-formed.
3307 bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
3308 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3309 Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
3310 << MD->getDeclName();
3311}
3312
3314 if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
3315 return;
3316 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
3317 if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
3318 return;
3319
3321 SourceLocation SpellingLoc = Loc;
3322 if (getSourceManager().isMacroArgExpansion(Loc))
3324 SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
3325 if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
3326 return;
3327
3328 if (MD->size_overridden_methods() > 0) {
3329 auto EmitDiag = [&](unsigned DiagInconsistent, unsigned DiagSuggest) {
3330 unsigned DiagID =
3331 Inconsistent && !Diags.isIgnored(DiagInconsistent, MD->getLocation())
3332 ? DiagInconsistent
3333 : DiagSuggest;
3334 Diag(MD->getLocation(), DiagID) << MD->getDeclName();
3335 const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
3336 Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
3337 };
3338 if (isa<CXXDestructorDecl>(MD))
3339 EmitDiag(
3340 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3341 diag::warn_suggest_destructor_marked_not_override_overriding);
3342 else
3343 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3344 diag::warn_suggest_function_marked_not_override_overriding);
3345 }
3346}
3347
3349 const CXXMethodDecl *Old) {
3350 FinalAttr *FA = Old->getAttr<FinalAttr>();
3351 if (!FA)
3352 return false;
3353
3354 Diag(New->getLocation(), diag::err_final_function_overridden)
3355 << New->getDeclName()
3356 << FA->isSpelledAsSealed();
3357 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3358 return true;
3359}
3360
3362 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
3363 // FIXME: Destruction of ObjC lifetime types has side-effects.
3364 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3365 return !RD->isCompleteDefinition() ||
3366 !RD->hasTrivialDefaultConstructor() ||
3367 !RD->hasTrivialDestructor();
3368 return false;
3369}
3370
3371void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
3372 DeclarationName FieldName,
3373 const CXXRecordDecl *RD,
3374 bool DeclIsField) {
3375 if (Diags.isIgnored(diag::warn_shadow_field, Loc))
3376 return;
3377
3378 // To record a shadowed field in a base
3379 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3380 auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
3381 CXXBasePath &Path) {
3382 const auto Base = Specifier->getType()->getAsCXXRecordDecl();
3383 // Record an ambiguous path directly
3384 if (Bases.find(Base) != Bases.end())
3385 return true;
3386 for (const auto Field : Base->lookup(FieldName)) {
3387 if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3388 Field->getAccess() != AS_private) {
3389 assert(Field->getAccess() != AS_none);
3390 assert(Bases.find(Base) == Bases.end());
3391 Bases[Base] = Field;
3392 return true;
3393 }
3394 }
3395 return false;
3396 };
3397
3398 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3399 /*DetectVirtual=*/true);
3400 if (!RD->lookupInBases(FieldShadowed, Paths))
3401 return;
3402
3403 for (const auto &P : Paths) {
3404 auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
3405 auto It = Bases.find(Base);
3406 // Skip duplicated bases
3407 if (It == Bases.end())
3408 continue;
3409 auto BaseField = It->second;
3410 assert(BaseField->getAccess() != AS_private);
3411 if (AS_none !=
3412 CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
3413 Diag(Loc, diag::warn_shadow_field)
3414 << FieldName << RD << Base << DeclIsField;
3415 Diag(BaseField->getLocation(), diag::note_shadow_field);
3416 Bases.erase(It);
3417 }
3418 }
3419}
3420
3421template <typename AttrType>
3422inline static bool HasAttribute(const QualType &T) {
3423 if (const TagDecl *TD = T->getAsTagDecl())
3424 return TD->hasAttr<AttrType>();
3425 if (const TypedefType *TDT = T->getAs<TypedefType>())
3426 return TDT->getDecl()->hasAttr<AttrType>();
3427 return false;
3428}
3429
3430static bool IsUnusedPrivateField(const FieldDecl *FD) {
3431 if (FD->getAccess() == AS_private && FD->getDeclName()) {
3432 QualType FieldType = FD->getType();
3433 if (HasAttribute<WarnUnusedAttr>(FieldType))
3434 return true;
3435
3436 return !FD->isImplicit() && !FD->hasAttr<UnusedAttr>() &&
3437 !FD->getParent()->isDependentContext() &&
3438 !HasAttribute<UnusedAttr>(FieldType) &&
3440 }
3441 return false;
3442}
3443
3444NamedDecl *
3446 MultiTemplateParamsArg TemplateParameterLists,
3447 Expr *BitWidth, const VirtSpecifiers &VS,
3448 InClassInitStyle InitStyle) {
3449 const DeclSpec &DS = D.getDeclSpec();
3451 DeclarationName Name = NameInfo.getName();
3452 SourceLocation Loc = NameInfo.getLoc();
3453
3454 // For anonymous bitfields, the location should point to the type.
3455 if (Loc.isInvalid())
3456 Loc = D.getBeginLoc();
3457
3458 assert(isa<CXXRecordDecl>(CurContext));
3459 assert(!DS.isFriendSpecified());
3460
3461 bool isFunc = D.isDeclarationOfFunction();
3462 const ParsedAttr *MSPropertyAttr =
3463 D.getDeclSpec().getAttributes().getMSPropertyAttr();
3464
3465 if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
3466 // The Microsoft extension __interface only permits public member functions
3467 // and prohibits constructors, destructors, operators, non-public member
3468 // functions, static methods and data members.
3469 unsigned InvalidDecl;
3470 bool ShowDeclName = true;
3471 if (!isFunc &&
3472 (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
3473 InvalidDecl = 0;
3474 else if (!isFunc)
3475 InvalidDecl = 1;
3476 else if (AS != AS_public)
3477 InvalidDecl = 2;
3479 InvalidDecl = 3;
3480 else switch (Name.getNameKind()) {
3482 InvalidDecl = 4;
3483 ShowDeclName = false;
3484 break;
3485
3487 InvalidDecl = 5;
3488 ShowDeclName = false;
3489 break;
3490
3493 InvalidDecl = 6;
3494 break;
3495
3496 default:
3497 InvalidDecl = 0;
3498 break;
3499 }
3500
3501 if (InvalidDecl) {
3502 if (ShowDeclName)
3503 Diag(Loc, diag::err_invalid_member_in_interface)
3504 << (InvalidDecl-1) << Name;
3505 else
3506 Diag(Loc, diag::err_invalid_member_in_interface)
3507 << (InvalidDecl-1) << "";
3508 return nullptr;
3509 }
3510 }
3511
3512 // C++ 9.2p6: A member shall not be declared to have automatic storage
3513 // duration (auto, register) or with the extern storage-class-specifier.
3514 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
3515 // data members and cannot be applied to names declared const or static,
3516 // and cannot be applied to reference members.
3517 switch (DS.getStorageClassSpec()) {
3521 break;
3523 if (isFunc) {
3524 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
3525
3526 // FIXME: It would be nicer if the keyword was ignored only for this
3527 // declarator. Otherwise we could get follow-up errors.
3528 D.getMutableDeclSpec().ClearStorageClassSpecs();
3529 }
3530 break;
3531 default:
3533 diag::err_storageclass_invalid_for_member);
3534 D.getMutableDeclSpec().ClearStorageClassSpecs();
3535 break;
3536 }
3537
3538 bool isInstField = (DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
3540 !isFunc && TemplateParameterLists.empty();
3541
3542 if (DS.hasConstexprSpecifier() && isInstField) {
3544 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
3545 SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
3546 if (InitStyle == ICIS_NoInit) {
3547 B << 0 << 0;
3548 if (D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const)
3549 B << FixItHint::CreateRemoval(ConstexprLoc);
3550 else {
3551 B << FixItHint::CreateReplacement(ConstexprLoc, "const");
3552 D.getMutableDeclSpec().ClearConstexprSpec();
3553 const char *PrevSpec;
3554 unsigned DiagID;
3555 bool Failed = D.getMutableDeclSpec().SetTypeQual(
3556 DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
3557 (void)Failed;
3558 assert(!Failed && "Making a constexpr member const shouldn't fail");
3559 }
3560 } else {
3561 B << 1;
3562 const char *PrevSpec;
3563 unsigned DiagID;
3564 if (D.getMutableDeclSpec().SetStorageClassSpec(
3565 *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
3568 "This is the only DeclSpec that should fail to be applied");
3569 B << 1;
3570 } else {
3571 B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
3572 isInstField = false;
3573 }
3574 }
3575 }
3576
3578 if (isInstField) {
3579 CXXScopeSpec &SS = D.getCXXScopeSpec();
3580
3581 // Data members must have identifiers for names.
3582 if (!Name.isIdentifier()) {
3583 Diag(Loc, diag::err_bad_variable_name)
3584 << Name;
3585 return nullptr;
3586 }
3587
3588 IdentifierInfo *II = Name.getAsIdentifierInfo();
3589 if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
3590 Diag(D.getIdentifierLoc(), diag::err_member_with_template_arguments)
3591 << II
3592 << SourceRange(D.getName().TemplateId->LAngleLoc,
3593 D.getName().TemplateId->RAngleLoc)
3594 << D.getName().TemplateId->LAngleLoc;
3595 D.SetIdentifier(II, Loc);
3596 }
3597
3598 if (SS.isSet() && !SS.isInvalid()) {
3599 // The user provided a superfluous scope specifier inside a class
3600 // definition:
3601 //
3602 // class X {
3603 // int X::member;
3604 // };
3605 if (DeclContext *DC = computeDeclContext(SS, false)) {
3606 TemplateIdAnnotation *TemplateId =
3608 ? D.getName().TemplateId
3609 : nullptr;
3610 diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc(),
3611 TemplateId,
3612 /*IsMemberSpecialization=*/false);
3613 } else {
3614 Diag(D.getIdentifierLoc(), diag::err_member_qualification)
3615 << Name << SS.getRange();
3616 }
3617 SS.clear();
3618 }
3619
3620 if (MSPropertyAttr) {
3621 Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3622 BitWidth, InitStyle, AS, *MSPropertyAttr);
3623 if (!Member)
3624 return nullptr;
3625 isInstField = false;
3626 } else {
3627 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3628 BitWidth, InitStyle, AS);
3629 if (!Member)
3630 return nullptr;
3631 }
3632
3633 CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
3634 } else {
3635 Member = HandleDeclarator(S, D, TemplateParameterLists);
3636 if (!Member)
3637 return nullptr;
3638
3639 // Non-instance-fields can't have a bitfield.
3640 if (BitWidth) {
3641 if (Member->isInvalidDecl()) {
3642 // don't emit another diagnostic.
3643 } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
3644 // C++ 9.6p3: A bit-field shall not be a static member.
3645 // "static member 'A' cannot be a bit-field"
3646 Diag(Loc, diag::err_static_not_bitfield)
3647 << Name << BitWidth->getSourceRange();
3648 } else if (isa<TypedefDecl>(Member)) {
3649 // "typedef member 'x' cannot be a bit-field"
3650 Diag(Loc, diag::err_typedef_not_bitfield)
3651 << Name << BitWidth->getSourceRange();
3652 } else {
3653 // A function typedef ("typedef int f(); f a;").
3654 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3655 Diag(Loc, diag::err_not_integral_type_bitfield)
3656 << Name << cast<ValueDecl>(Member)->getType()
3657 << BitWidth->getSourceRange();
3658 }
3659
3660 BitWidth = nullptr;
3661 Member->setInvalidDecl();
3662 }
3663
3664 NamedDecl *NonTemplateMember = Member;
3665 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
3666 NonTemplateMember = FunTmpl->getTemplatedDecl();
3667 else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
3668 NonTemplateMember = VarTmpl->getTemplatedDecl();
3669
3670 Member->setAccess(AS);
3671
3672 // If we have declared a member function template or static data member
3673 // template, set the access of the templated declaration as well.
3674 if (NonTemplateMember != Member)
3675 NonTemplateMember->setAccess(AS);
3676
3677 // C++ [temp.deduct.guide]p3:
3678 // A deduction guide [...] for a member class template [shall be
3679 // declared] with the same access [as the template].
3680 if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3681 auto *TD = DG->getDeducedTemplate();
3682 // Access specifiers are only meaningful if both the template and the
3683 // deduction guide are from the same scope.
3684 if (AS != TD->getAccess() &&
3685 TD->getDeclContext()->getRedeclContext()->Equals(
3686 DG->getDeclContext()->getRedeclContext())) {
3687 Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3688 Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3689 << TD->getAccess();
3690 const AccessSpecDecl *LastAccessSpec = nullptr;
3691 for (const auto *D : cast<CXXRecordDecl>(CurContext)->decls()) {
3692 if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3693 LastAccessSpec = AccessSpec;
3694 }
3695 assert(LastAccessSpec && "differing access with no access specifier");
3696 Diag(LastAccessSpec->getBeginLoc(), diag::note_deduction_guide_access)
3697 << AS;
3698 }
3699 }
3700 }
3701
3702 if (VS.isOverrideSpecified())
3703 Member->addAttr(OverrideAttr::Create(Context, VS.getOverrideLoc()));
3704 if (VS.isFinalSpecified())
3705 Member->addAttr(FinalAttr::Create(Context, VS.getFinalLoc(),
3707 ? FinalAttr::Keyword_sealed
3708 : FinalAttr::Keyword_final));
3709
3710 if (VS.getLastLocation().isValid()) {
3711 // Update the end location of a method that has a virt-specifiers.
3712 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
3713 MD->setRangeEnd(VS.getLastLocation());
3714 }
3715
3717
3718 assert((Name || isInstField) && "No identifier for non-field ?");
3719
3720 if (isInstField) {
3721 FieldDecl *FD = cast<FieldDecl>(Member);
3722 FieldCollector->Add(FD);
3723
3724 if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation()) &&
3726 // Remember all explicit private FieldDecls that have a name, no side
3727 // effects and are not part of a dependent type declaration.
3728 UnusedPrivateFields.insert(FD);
3729 }
3730 }
3731
3732 return Member;
3733}
3734
3735namespace {
3736 class UninitializedFieldVisitor
3737 : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
3738 Sema &S;
3739 // List of Decls to generate a warning on. Also remove Decls that become
3740 // initialized.
3741 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3742 // List of base classes of the record. Classes are removed after their
3743 // initializers.
3744 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3745 // Vector of decls to be removed from the Decl set prior to visiting the
3746 // nodes. These Decls may have been initialized in the prior initializer.
3748 // If non-null, add a note to the warning pointing back to the constructor.
3750 // Variables to hold state when processing an initializer list. When
3751 // InitList is true, special case initialization of FieldDecls matching
3752 // InitListFieldDecl.
3753 bool InitList;
3754 FieldDecl *InitListFieldDecl;
3755 llvm::SmallVector<unsigned, 4> InitFieldIndex;
3756
3757 public:
3759 UninitializedFieldVisitor(Sema &S,
3760 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3761 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3762 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3763 Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
3764
3765 // Returns true if the use of ME is not an uninitialized use.
3766 bool IsInitListMemberExprInitialized(MemberExpr *ME,
3767 bool CheckReferenceOnly) {
3769 bool ReferenceField = false;
3770 while (ME) {
3771 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
3772 if (!FD)
3773 return false;
3774 Fields.push_back(FD);
3775 if (FD->getType()->isReferenceType())
3776 ReferenceField = true;
3777 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
3778 }
3779
3780 // Binding a reference to an uninitialized field is not an
3781 // uninitialized use.
3782 if (CheckReferenceOnly && !ReferenceField)
3783 return true;
3784
3785 llvm::SmallVector<unsigned, 4> UsedFieldIndex;
3786 // Discard the first field since it is the field decl that is being
3787 // initialized.
3788 for (const FieldDecl *FD : llvm::drop_begin(llvm::reverse(Fields)))
3789 UsedFieldIndex.push_back(FD->getFieldIndex());
3790
3791 for (auto UsedIter = UsedFieldIndex.begin(),
3792 UsedEnd = UsedFieldIndex.end(),
3793 OrigIter = InitFieldIndex.begin(),
3794 OrigEnd = InitFieldIndex.end();
3795 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3796 if (*UsedIter < *OrigIter)
3797 return true;
3798 if (*UsedIter > *OrigIter)
3799 break;
3800 }
3801
3802 return false;
3803 }
3804
3805 void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
3806 bool AddressOf) {
3807 if (isa<EnumConstantDecl>(ME->getMemberDecl()))
3808 return;
3809
3810 // FieldME is the inner-most MemberExpr that is not an anonymous struct
3811 // or union.
3812 MemberExpr *FieldME = ME;
3813
3814 bool AllPODFields = FieldME->getType().isPODType(S.Context);
3815
3816 Expr *Base = ME;
3817 while (MemberExpr *SubME =
3818 dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
3819
3820 if (isa<VarDecl>(SubME->getMemberDecl()))
3821 return;
3822
3823 if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3824 if (!FD->isAnonymousStructOrUnion())
3825 FieldME = SubME;
3826
3827 if (!FieldME->getType().isPODType(S.Context))
3828 AllPODFields = false;
3829
3830 Base = SubME->getBase();
3831 }
3832
3833 if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts())) {
3834 Visit(Base);
3835 return;
3836 }
3837
3838 if (AddressOf && AllPODFields)
3839 return;
3840
3841 ValueDecl* FoundVD = FieldME->getMemberDecl();
3842
3843 if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
3844 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3845 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3846 }
3847
3848 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3849 QualType T = BaseCast->getType();
3850 if (T->isPointerType() &&
3851 BaseClasses.count(T->getPointeeType())) {
3852 S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
3853 << T->getPointeeType() << FoundVD;
3854 }
3855 }
3856 }
3857
3858 if (!Decls.count(FoundVD))
3859 return;
3860
3861 const bool IsReference = FoundVD->getType()->isReferenceType();
3862
3863 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3864 // Special checking for initializer lists.
3865 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3866 return;
3867 }
3868 } else {
3869 // Prevent double warnings on use of unbounded references.
3870 if (CheckReferenceOnly && !IsReference)
3871 return;
3872 }
3873
3874 unsigned diag = IsReference
3875 ? diag::warn_reference_field_is_uninit
3876 : diag::warn_field_is_uninit;
3877 S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
3878 if (Constructor)
3879 S.Diag(Constructor->getLocation(),
3880 diag::note_uninit_in_this_constructor)
3881 << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
3882
3883 }
3884
3885 void HandleValue(Expr *E, bool AddressOf) {
3886 E = E->IgnoreParens();
3887
3888 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3889 HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
3890 AddressOf /*AddressOf*/);
3891 return;
3892 }
3893
3894 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
3895 Visit(CO->getCond());
3896 HandleValue(CO->getTrueExpr(), AddressOf);
3897 HandleValue(CO->getFalseExpr(), AddressOf);
3898 return;
3899 }
3900
3901 if (BinaryConditionalOperator *BCO =
3902 dyn_cast<BinaryConditionalOperator>(E)) {
3903 Visit(BCO->getCond());
3904 HandleValue(BCO->getFalseExpr(), AddressOf);
3905 return;
3906 }
3907
3908 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
3909 HandleValue(OVE->getSourceExpr(), AddressOf);
3910 return;
3911 }
3912
3913 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3914 switch (BO->getOpcode()) {
3915 default:
3916 break;
3917 case(BO_PtrMemD):
3918 case(BO_PtrMemI):
3919 HandleValue(BO->getLHS(), AddressOf);
3920 Visit(BO->getRHS());
3921 return;
3922 case(BO_Comma):
3923 Visit(BO->getLHS());
3924 HandleValue(BO->getRHS(), AddressOf);
3925 return;
3926 }
3927 }
3928
3929 Visit(E);
3930 }
3931
3932 void CheckInitListExpr(InitListExpr *ILE) {
3933 InitFieldIndex.push_back(0);
3934 for (auto *Child : ILE->children()) {
3935 if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3936 CheckInitListExpr(SubList);
3937 } else {
3938 Visit(Child);
3939 }
3940 ++InitFieldIndex.back();
3941 }
3942 InitFieldIndex.pop_back();
3943 }
3944
3945 void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3946 FieldDecl *Field, const Type *BaseClass) {
3947 // Remove Decls that may have been initialized in the previous
3948 // initializer.
3949 for (ValueDecl* VD : DeclsToRemove)
3950 Decls.erase(VD);
3951 DeclsToRemove.clear();
3952
3953 Constructor = FieldConstructor;
3954 InitListExpr *ILE = dyn_cast<InitListExpr>(E);
3955
3956 if (ILE && Field) {
3957 InitList = true;
3958 InitListFieldDecl = Field;
3959 InitFieldIndex.clear();
3960 CheckInitListExpr(ILE);
3961 } else {
3962 InitList = false;
3963 Visit(E);
3964 }
3965
3966 if (Field)
3967 Decls.erase(Field);
3968 if (BaseClass)
3969 BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
3970 }
3971
3972 void VisitMemberExpr(MemberExpr *ME) {
3973 // All uses of unbounded reference fields will warn.
3974 HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
3975 }
3976
3977 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
3978 if (E->getCastKind() == CK_LValueToRValue) {
3979 HandleValue(E->getSubExpr(), false /*AddressOf*/);
3980 return;
3981 }
3982
3983 Inherited::VisitImplicitCastExpr(E);
3984 }
3985
3986 void VisitCXXConstructExpr(CXXConstructExpr *E) {
3987 if (E->getConstructor()->isCopyConstructor()) {
3988 Expr *ArgExpr = E->getArg(0);
3989 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3990 if (ILE->getNumInits() == 1)
3991 ArgExpr = ILE->getInit(0);
3992 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
3993 if (ICE->getCastKind() == CK_NoOp)
3994 ArgExpr = ICE->getSubExpr();
3995 HandleValue(ArgExpr, false /*AddressOf*/);
3996 return;
3997 }
3998 Inherited::VisitCXXConstructExpr(E);
3999 }
4000
4001 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
4002 Expr *Callee = E->getCallee();
4003 if (isa<MemberExpr>(Callee)) {
4004 HandleValue(Callee, false /*AddressOf*/);
4005 for (auto *Arg : E->arguments())
4006 Visit(Arg);
4007 return;
4008 }
4009
4010 Inherited::VisitCXXMemberCallExpr(E);
4011 }
4012
4013 void VisitCallExpr(CallExpr *E) {
4014 // Treat std::move as a use.
4015 if (E->isCallToStdMove()) {
4016 HandleValue(E->getArg(0), /*AddressOf=*/false);
4017 return;
4018 }
4019
4020 Inherited::VisitCallExpr(E);
4021 }
4022
4023 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
4024 Expr *Callee = E->getCallee();
4025
4026 if (isa<UnresolvedLookupExpr>(Callee))
4027 return Inherited::VisitCXXOperatorCallExpr(E);
4028
4029 Visit(Callee);
4030 for (auto *Arg : E->arguments())
4031 HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
4032 }
4033
4034 void VisitBinaryOperator(BinaryOperator *E) {
4035 // If a field assignment is detected, remove the field from the
4036 // uninitiailized field set.
4037 if (E->getOpcode() == BO_Assign)
4038 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
4039 if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
4040 if (!FD->getType()->isReferenceType())
4041 DeclsToRemove.push_back(FD);
4042
4043 if (E->isCompoundAssignmentOp()) {
4044 HandleValue(E->getLHS(), false /*AddressOf*/);
4045 Visit(E->getRHS());
4046 return;
4047 }
4048
4049 Inherited::VisitBinaryOperator(E);
4050 }
4051
4052 void VisitUnaryOperator(UnaryOperator *E) {
4053 if (E->isIncrementDecrementOp()) {
4054 HandleValue(E->getSubExpr(), false /*AddressOf*/);
4055 return;
4056 }
4057 if (E->getOpcode() == UO_AddrOf) {
4058 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
4059 HandleValue(ME->getBase(), true /*AddressOf*/);
4060 return;
4061 }
4062 }
4063
4064 Inherited::VisitUnaryOperator(E);
4065 }
4066 };
4067
4068 // Diagnose value-uses of fields to initialize themselves, e.g.
4069 // foo(foo)
4070 // where foo is not also a parameter to the constructor.
4071 // Also diagnose across field uninitialized use such as
4072 // x(y), y(x)
4073 // TODO: implement -Wuninitialized and fold this into that framework.
4074 static void DiagnoseUninitializedFields(
4076
4077 if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
4078 Constructor->getLocation())) {
4079 return;
4080 }
4081
4082 if (Constructor->isInvalidDecl())
4083 return;
4084
4085 const CXXRecordDecl *RD = Constructor->getParent();
4086
4087 if (RD->isDependentContext())
4088 return;
4089
4090 // Holds fields that are uninitialized.
4091 llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
4092
4093 // At the beginning, all fields are uninitialized.
4094 for (auto *I : RD->decls()) {
4095 if (auto *FD = dyn_cast<FieldDecl>(I)) {
4096 UninitializedFields.insert(FD);
4097 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
4098 UninitializedFields.insert(IFD->getAnonField());
4099 }
4100 }
4101
4102 llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
4103 for (const auto &I : RD->bases())
4104 UninitializedBaseClasses.insert(I.getType().getCanonicalType());
4105
4106 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4107 return;
4108
4109 UninitializedFieldVisitor UninitializedChecker(SemaRef,
4110 UninitializedFields,
4111 UninitializedBaseClasses);
4112
4113 for (const auto *FieldInit : Constructor->inits()) {
4114 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4115 break;
4116
4117 Expr *InitExpr = FieldInit->getInit();
4118 if (!InitExpr)
4119 continue;
4120
4122 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
4123 InitExpr = Default->getExpr();
4124 if (!InitExpr)
4125 continue;
4126 // In class initializers will point to the constructor.
4127 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
4128 FieldInit->getAnyMember(),
4129 FieldInit->getBaseClass());
4130 } else {
4131 UninitializedChecker.CheckInitializer(InitExpr, nullptr,
4132 FieldInit->getAnyMember(),
4133 FieldInit->getBaseClass());
4134 }
4135 }
4136 }
4137} // namespace
4138
4140 // Create a synthetic function scope to represent the call to the constructor
4141 // that notionally surrounds a use of this initializer.
4143}
4144
4146 if (!D.isFunctionDeclarator())
4147 return;
4148 auto &FTI = D.getFunctionTypeInfo();
4149 if (!FTI.Params)
4150 return;
4151 for (auto &Param : ArrayRef<DeclaratorChunk::ParamInfo>(FTI.Params,
4152 FTI.NumParams)) {
4153 auto *ParamDecl = cast<NamedDecl>(Param.Param);
4154 if (ParamDecl->getDeclName())
4155 PushOnScopeChains(ParamDecl, S, /*AddToContext=*/false);
4156 }
4157}
4158
4160 return ActOnRequiresClause(ConstraintExpr);
4161}
4162
4164 if (ConstraintExpr.isInvalid())
4165 return ExprError();
4166
4167 if (DiagnoseUnexpandedParameterPack(ConstraintExpr.get(),
4169 return ExprError();
4170
4171 return ConstraintExpr;
4172}
4173
4175 Expr *InitExpr,
4176 SourceLocation InitLoc) {
4177 InitializedEntity Entity =
4179 InitializationKind Kind =
4182 InitExpr->getBeginLoc(),
4183 InitExpr->getEndLoc())
4184 : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
4185 InitializationSequence Seq(*this, Entity, Kind, InitExpr);
4186 return Seq.Perform(*this, Entity, Kind, InitExpr);
4187}
4188
4190 SourceLocation InitLoc,
4191 ExprResult InitExpr) {
4192 // Pop the notional constructor scope we created earlier.
4193 PopFunctionScopeInfo(nullptr, D);
4194
4195 // Microsoft C++'s property declaration cannot have a default member
4196 // initializer.
4197 if (isa<MSPropertyDecl>(D)) {
4198 D->setInvalidDecl();
4199 return;
4200 }
4201
4202 FieldDecl *FD = dyn_cast<FieldDecl>(D);
4203 assert((FD && FD->getInClassInitStyle() != ICIS_NoInit) &&
4204 "must set init style when field is created");
4205
4206 if (!InitExpr.isUsable() ||
4208 FD->setInvalidDecl();
4209 ExprResult RecoveryInit =
4210 CreateRecoveryExpr(InitLoc, InitLoc, {}, FD->getType());
4211 if (RecoveryInit.isUsable())
4212 FD->setInClassInitializer(RecoveryInit.get());
4213 return;
4214 }
4215
4216 if (!FD->getType()->isDependentType() && !InitExpr.get()->isTypeDependent()) {
4217 InitExpr = ConvertMemberDefaultInitExpression(FD, InitExpr.get(), InitLoc);
4218 // C++11 [class.base.init]p7:
4219 // The initialization of each base and member constitutes a
4220 // full-expression.
4221 if (!InitExpr.isInvalid())
4222 InitExpr = ActOnFinishFullExpr(InitExpr.get(), /*DiscarededValue=*/false);
4223 if (InitExpr.isInvalid()) {
4224 FD->setInvalidDecl();
4225 return;
4226 }
4227 }
4228
4229 FD->setInClassInitializer(InitExpr.get());
4230}
4231
4232/// Find the direct and/or virtual base specifiers that
4233/// correspond to the given base type, for use in base initialization
4234/// within a constructor.
4236 CXXRecordDecl *ClassDecl,
4237 QualType BaseType,
4238 const CXXBaseSpecifier *&DirectBaseSpec,
4239 const CXXBaseSpecifier *&VirtualBaseSpec) {
4240 // First, check for a direct base class.
4241 DirectBaseSpec = nullptr;
4242 for (const auto &Base : ClassDecl->bases()) {
4243 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
4244 // We found a direct base of this type. That's what we're
4245 // initializing.
4246 DirectBaseSpec = &Base;
4247 break;
4248 }
4249 }
4250
4251 // Check for a virtual base class.
4252 // FIXME: We might be able to short-circuit this if we know in advance that
4253 // there are no virtual bases.
4254 VirtualBaseSpec = nullptr;
4255 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
4256 // We haven't found a base yet; search the class hierarchy for a
4257 // virtual base class.
4258 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
4259 /*DetectVirtual=*/false);
4260 if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
4262 BaseType, Paths)) {
4263 for (CXXBasePaths::paths_iterator Path = Paths.begin();
4264 Path != Paths.end(); ++Path) {
4265 if (Path->back().Base->isVirtual()) {
4266 VirtualBaseSpec = Path->back().Base;
4267 break;
4268 }
4269 }
4270 }
4271 }
4272
4273 return DirectBaseSpec || VirtualBaseSpec;
4274}
4275
4278 Scope *S,
4279 CXXScopeSpec &SS,
4280 IdentifierInfo *MemberOrBase,
4281 ParsedType TemplateTypeTy,
4282 const DeclSpec &DS,
4283 SourceLocation IdLoc,
4284 Expr *InitList,
4285 SourceLocation EllipsisLoc) {
4286 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4287 DS, IdLoc, InitList,
4288 EllipsisLoc);
4289}
4290
4293 Scope *S,
4294 CXXScopeSpec &SS,
4295 IdentifierInfo *MemberOrBase,
4296 ParsedType TemplateTypeTy,
4297 const DeclSpec &DS,
4298 SourceLocation IdLoc,
4299 SourceLocation LParenLoc,
4300 ArrayRef<Expr *> Args,
4301 SourceLocation RParenLoc,
4302 SourceLocation EllipsisLoc) {
4303 Expr *List = ParenListExpr::Create(Context, LParenLoc, Args, RParenLoc);
4304 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4305 DS, IdLoc, List, EllipsisLoc);
4306}
4307
4308namespace {
4309
4310// Callback to only accept typo corrections that can be a valid C++ member
4311// initializer: either a non-static field member or a base class.
4312class MemInitializerValidatorCCC final : public CorrectionCandidateCallback {
4313public:
4314 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
4315 : ClassDecl(ClassDecl) {}
4316
4317 bool ValidateCandidate(const TypoCorrection &candidate) override {
4318 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
4319 if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
4320 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4321 return isa<TypeDecl>(ND);
4322 }
4323 return false;
4324 }
4325
4326 std::unique_ptr<CorrectionCandidateCallback> clone() override {
4327 return std::make_unique<MemInitializerValidatorCCC>(*this);
4328 }
4329
4330private:
4331 CXXRecordDecl *ClassDecl;
4332};
4333
4334}
4335
4337 RecordDecl *ClassDecl,
4338 const IdentifierInfo *Name) {
4339 DeclContextLookupResult Result = ClassDecl->lookup(Name);
4341 llvm::find_if(Result, [this](const NamedDecl *Elem) {
4342 return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
4344 });
4345 // We did not find a placeholder variable
4346 if (Found == Result.end())
4347 return false;
4348 Diag(Loc, diag::err_using_placeholder_variable) << Name;
4349 for (DeclContextLookupResult::iterator It = Found; It != Result.end(); It++) {
4350 const NamedDecl *ND = *It;
4351 if (ND->getDeclContext() != ND->getDeclContext())
4352 break;
4353 if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
4355 Diag(ND->getLocation(), diag::note_reference_placeholder) << ND;
4356 }
4357 return true;
4358}
4359
4360ValueDecl *
4362 const IdentifierInfo *MemberOrBase) {
4363 ValueDecl *ND = nullptr;
4364 for (auto *D : ClassDecl->lookup(MemberOrBase)) {
4365 if (isa<FieldDecl, IndirectFieldDecl>(D)) {
4366 bool IsPlaceholder = D->isPlaceholderVar(getLangOpts());
4367 if (ND) {
4368 if (IsPlaceholder && D->getDeclContext() == ND->getDeclContext())
4369 return nullptr;
4370 break;
4371 }
4372 if (!IsPlaceholder)
4373 return cast<ValueDecl>(D);
4374 ND = cast<ValueDecl>(D);
4375 }
4376 }
4377 return ND;
4378}
4379
4381 CXXScopeSpec &SS,
4382 ParsedType TemplateTypeTy,
4383 IdentifierInfo *MemberOrBase) {
4384 if (SS.getScopeRep() || TemplateTypeTy)
4385 return nullptr;
4386 return tryLookupUnambiguousFieldDecl(ClassDecl, MemberOrBase);
4387}
4388
4391 Scope *S,
4392 CXXScopeSpec &SS,
4393 IdentifierInfo *MemberOrBase,
4394 ParsedType TemplateTypeTy,
4395 const DeclSpec &DS,
4396 SourceLocation IdLoc,
4397 Expr *Init,
4398 SourceLocation EllipsisLoc) {
4399 if (!ConstructorD || !Init)
4400 return true;
4401
4402 AdjustDeclIfTemplate(ConstructorD);
4403
4405 = dyn_cast<CXXConstructorDecl>(ConstructorD);
4406 if (!Constructor) {
4407 // The user wrote a constructor initializer on a function that is
4408 // not a C++ constructor. Ignore the error for now, because we may
4409 // have more member initializers coming; we'll diagnose it just
4410 // once in ActOnMemInitializers.
4411 return true;
4412 }
4413
4414 CXXRecordDecl *ClassDecl = Constructor->getParent();
4415
4416 // C++ [class.base.init]p2:
4417 // Names in a mem-initializer-id are looked up in the scope of the
4418 // constructor's class and, if not found in that scope, are looked
4419 // up in the scope containing the constructor's definition.
4420 // [Note: if the constructor's class contains a member with the
4421 // same name as a direct or virtual base class of the class, a
4422 // mem-initializer-id naming the member or base class and composed
4423 // of a single identifier refers to the class member. A
4424 // mem-initializer-id for the hidden base class may be specified
4425 // using a qualified name. ]
4426
4427 // Look for a member, first.
4429 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4430 if (EllipsisLoc.isValid())
4431 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4432 << MemberOrBase
4433 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4434
4435 return BuildMemberInitializer(Member, Init, IdLoc);
4436 }
4437 // It didn't name a member, so see if it names a class.
4438 QualType BaseType;
4439 TypeSourceInfo *TInfo = nullptr;
4440
4441 if (TemplateTypeTy) {
4442 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
4443 if (BaseType.isNull())
4444 return true;
4445 } else if (DS.getTypeSpecType() == TST_decltype) {
4446 BaseType = BuildDecltypeType(DS.getRepAsExpr());
4447 } else if (DS.getTypeSpecType() == TST_decltype_auto) {
4448 Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
4449 return true;
4450 } else if (DS.getTypeSpecType() == TST_typename_pack_indexing) {
4451 BaseType =
4453 DS.getBeginLoc(), DS.getEllipsisLoc());
4454 } else {
4455 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
4456 LookupParsedName(R, S, &SS, /*ObjectType=*/QualType());
4457
4458 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
4459 if (!TyD) {
4460 if (R.isAmbiguous()) return true;
4461
4462 // We don't want access-control diagnostics here.
4464
4465 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
4466 bool NotUnknownSpecialization = false;
4467 DeclContext *DC = computeDeclContext(SS, false);
4468 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
4469 NotUnknownSpecialization = !Record->hasAnyDependentBases();
4470
4471 if (!NotUnknownSpecialization) {
4472 // When the scope specifier can refer to a member of an unknown
4473 // specialization, we take it as a type name.
4474 BaseType = CheckTypenameType(
4476 SS.getWithLocInContext(Context), *MemberOrBase, IdLoc);
4477 if (BaseType.isNull())
4478 return true;
4479
4480 TInfo = Context.CreateTypeSourceInfo(BaseType);
4483 if (!TL.isNull()) {
4484 TL.setNameLoc(IdLoc);
4487 }
4488
4489 R.clear();
4490 R.setLookupName(MemberOrBase);
4491 }
4492 }
4493
4494 if (getLangOpts().MSVCCompat && !getLangOpts().CPlusPlus20) {
4495 if (auto UnqualifiedBase = R.getAsSingle<ClassTemplateDecl>()) {
4496 auto *TempSpec = cast<TemplateSpecializationType>(
4497 UnqualifiedBase->getCanonicalInjectedSpecializationType(Context));
4498 TemplateName TN = TempSpec->getTemplateName();
4499 for (auto const &Base : ClassDecl->bases()) {
4500 auto BaseTemplate =
4501 Base.getType()->getAs<TemplateSpecializationType>();
4502 if (BaseTemplate &&
4503 Context.hasSameTemplateName(BaseTemplate->getTemplateName(), TN,
4504 /*IgnoreDeduced=*/true)) {
4505 Diag(IdLoc, diag::ext_unqualified_base_class)
4506 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4507 BaseType = Base.getType();
4508 break;
4509 }
4510 }
4511 }
4512 }
4513
4514 // If no results were found, try to correct typos.
4515 TypoCorrection Corr;
4516 MemInitializerValidatorCCC CCC(ClassDecl);
4517 if (R.empty() && BaseType.isNull() &&
4518 (Corr =
4520 CCC, CorrectTypoKind::ErrorRecovery, ClassDecl))) {
4522 // We have found a non-static data member with a similar
4523 // name to what was typed; complain and initialize that
4524 // member.
4525 diagnoseTypo(Corr,
4526 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4527 << MemberOrBase << true);
4528 return BuildMemberInitializer(Member, Init, IdLoc);
4529 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
4530 const CXXBaseSpecifier *DirectBaseSpec;
4531 const CXXBaseSpecifier *VirtualBaseSpec;
4532 if (FindBaseInitializer(*this, ClassDecl,
4534 DirectBaseSpec, VirtualBaseSpec)) {
4535 // We have found a direct or virtual base class with a
4536 // similar name to what was typed; complain and initialize
4537 // that base class.
4538 diagnoseTypo(Corr,
4539 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4540 << MemberOrBase << false,
4541 PDiag() /*Suppress note, we provide our own.*/);
4542
4543 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
4544 : VirtualBaseSpec;
4545 Diag(BaseSpec->getBeginLoc(), diag::note_base_class_specified_here)
4546 << BaseSpec->getType() << BaseSpec->getSourceRange();
4547
4548 TyD = Type;
4549 }
4550 }
4551 }
4552
4553 if (!TyD && BaseType.isNull()) {
4554 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4555 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
4556 return true;
4557 }
4558 }
4559
4560 if (BaseType.isNull()) {
4561 MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
4562
4563 TypeLocBuilder TLB;
4564 // FIXME: This is missing building the UsingType for TyD, if any.
4565 if (const auto *TD = dyn_cast<TagDecl>(TyD)) {
4567 SS.getScopeRep(), TD, /*OwnsTag=*/false);
4568 auto TL = TLB.push<TagTypeLoc>(BaseType);
4570 TL.setQualifierLoc(SS.getWithLocInContext(Context));
4571 TL.setNameLoc(IdLoc);
4572 } else if (auto *TN = dyn_cast<TypedefNameDecl>(TyD)) {
4574 SS.getScopeRep(), TN);
4575 TLB.push<TypedefTypeLoc>(BaseType).set(
4576 /*ElaboratedKeywordLoc=*/SourceLocation(),
4577 SS.getWithLocInContext(Context), IdLoc);
4578 } else if (auto *UD = dyn_cast<UnresolvedUsingTypenameDecl>(TyD)) {
4580 SS.getScopeRep(), UD);
4581 TLB.push<UnresolvedUsingTypeLoc>(BaseType).set(
4582 /*ElaboratedKeywordLoc=*/SourceLocation(),
4583 SS.getWithLocInContext(Context), IdLoc);
4584 } else {
4585 // FIXME: What else can appear here?
4586 assert(SS.isEmpty());
4587 BaseType = Context.getTypeDeclType(TyD);
4588 TLB.pushTypeSpec(BaseType).setNameLoc(IdLoc);
4589 }
4590 TInfo = TLB.getTypeSourceInfo(Context, BaseType);
4591 }
4592 }
4593
4594 if (!TInfo)
4595 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
4596
4597 return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
4598}
4599
4602 SourceLocation IdLoc) {
4603 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
4604 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
4605 assert((DirectMember || IndirectMember) &&
4606 "Member must be a FieldDecl or IndirectFieldDecl");
4607
4609 return true;
4610
4611 if (Member->isInvalidDecl())
4612 return true;
4613
4614 MultiExprArg Args;
4615 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4616 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4617 } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
4618 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
4619 } else {
4620 // Template instantiation doesn't reconstruct ParenListExprs for us.
4621 Args = Init;
4622 }
4623
4624 SourceRange InitRange = Init->getSourceRange();
4625
4626 if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
4627 // Can't check initialization for a member of dependent type or when
4628 // any of the arguments are type-dependent expressions.
4630 } else {
4631 bool InitList = false;
4632 if (isa<InitListExpr>(Init)) {
4633 InitList = true;
4634 Args = Init;
4635 }
4636
4637 // Initialize the member.
4638 InitializedEntity MemberEntity =
4639 DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
4640 : InitializedEntity::InitializeMember(IndirectMember,
4641 nullptr);
4642 InitializationKind Kind =
4644 IdLoc, Init->getBeginLoc(), Init->getEndLoc())
4645 : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
4646 InitRange.getEnd());
4647
4648 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
4649 ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
4650 nullptr);
4651 if (!MemberInit.isInvalid()) {
4652 // C++11 [class.base.init]p7:
4653 // The initialization of each base and member constitutes a
4654 // full-expression.
4655 MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin(),
4656 /*DiscardedValue*/ false);
4657 }
4658
4659 if (MemberInit.isInvalid()) {
4660 // Args were sensible expressions but we couldn't initialize the member
4661 // from them. Preserve them in a RecoveryExpr instead.
4662 Init = CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(), Args,
4663 Member->getType())
4664 .get();
4665 if (!Init)
4666 return true;
4667 } else {
4668 Init = MemberInit.get();
4669 }
4670 }
4671
4672 if (DirectMember) {
4673 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
4674 InitRange.getBegin(), Init,
4675 InitRange.getEnd());
4676 } else {
4677 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
4678 InitRange.getBegin(), Init,
4679 InitRange.getEnd());
4680 }
4681}
4682
4685 CXXRecordDecl *ClassDecl) {
4686 SourceLocation NameLoc = TInfo->getTypeLoc().getSourceRange().getBegin();
4687 if (!LangOpts.CPlusPlus11)
4688 return Diag(NameLoc, diag::err_delegating_ctor)
4689 << TInfo->getTypeLoc().getSourceRange();
4690 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4691
4692 bool InitList = true;
4693 MultiExprArg Args = Init;
4694 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4695 InitList = false;
4696 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4697 }
4698
4699 CanQualType ClassType = Context.getCanonicalTagType(ClassDecl);
4700
4701 SourceRange InitRange = Init->getSourceRange();
4702 // Initialize the object.
4703 InitializedEntity DelegationEntity =
4705 InitializationKind Kind =
4707 NameLoc, Init->getBeginLoc(), Init->getEndLoc())
4708 : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
4709 InitRange.getEnd());
4710 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
4711 ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
4712 Args, nullptr);
4713 if (!DelegationInit.isInvalid()) {
4714 assert((DelegationInit.get()->containsErrors() ||
4715 cast<CXXConstructExpr>(DelegationInit.get())->getConstructor()) &&
4716 "Delegating constructor with no target?");
4717
4718 // C++11 [class.base.init]p7:
4719 // The initialization of each base and member constitutes a
4720 // full-expression.
4721 DelegationInit = ActOnFinishFullExpr(
4722 DelegationInit.get(), InitRange.getBegin(), /*DiscardedValue*/ false);
4723 }
4724
4725 if (DelegationInit.isInvalid()) {
4726 DelegationInit = CreateRecoveryExpr(InitRange.getBegin(),
4727 InitRange.getEnd(), Args, ClassType);
4728 if (DelegationInit.isInvalid())
4729 return true;
4730 } else {
4731 // If we are in a dependent context, template instantiation will
4732 // perform this type-checking again. Just save the arguments that we
4733 // received in a ParenListExpr.
4734 // FIXME: This isn't quite ideal, since our ASTs don't capture all
4735 // of the information that we have about the base
4736 // initializer. However, deconstructing the ASTs is a dicey process,
4737 // and this approach is far more likely to get the corner cases right.
4739 DelegationInit = Init;
4740 }
4741
4742 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
4743 DelegationInit.getAs<Expr>(),
4744 InitRange.getEnd());
4745}
4746
4749 Expr *Init, CXXRecordDecl *ClassDecl,
4750 SourceLocation EllipsisLoc) {
4751 SourceLocation BaseLoc = BaseTInfo->getTypeLoc().getBeginLoc();
4752
4753 if (!BaseType->isDependentType() && !BaseType->isRecordType())
4754 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4755 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
4756
4757 // C++ [class.base.init]p2:
4758 // [...] Unless the mem-initializer-id names a nonstatic data
4759 // member of the constructor's class or a direct or virtual base
4760 // of that class, the mem-initializer is ill-formed. A
4761 // mem-initializer-list can initialize a base class using any
4762 // name that denotes that base class type.
4763
4764 // We can store the initializers in "as-written" form and delay analysis until
4765 // instantiation if the constructor is dependent. But not for dependent
4766 // (broken) code in a non-template! SetCtorInitializers does not expect this.
4768 (BaseType->isDependentType() || Init->isTypeDependent());
4769
4770 SourceRange InitRange = Init->getSourceRange();
4771 if (EllipsisLoc.isValid()) {
4772 // This is a pack expansion.
4773 if (!BaseType->containsUnexpandedParameterPack()) {
4774 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4775 << SourceRange(BaseLoc, InitRange.getEnd());
4776
4777 EllipsisLoc = SourceLocation();
4778 }
4779 } else {
4780 // Check for any unexpanded parameter packs.
4781 if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
4782 return true;
4783
4785 return true;
4786 }
4787
4788 // Check for direct and virtual base classes.
4789 const CXXBaseSpecifier *DirectBaseSpec = nullptr;
4790 const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
4791 if (!Dependent) {
4792 if (declaresSameEntity(ClassDecl, BaseType->getAsCXXRecordDecl()))
4793 return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
4794
4795 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
4796 VirtualBaseSpec);
4797
4798 // C++ [base.class.init]p2:
4799 // Unless the mem-initializer-id names a nonstatic data member of the
4800 // constructor's class or a direct or virtual base of that class, the
4801 // mem-initializer is ill-formed.
4802 if (!DirectBaseSpec && !VirtualBaseSpec) {
4803 // If the class has any dependent bases, then it's possible that
4804 // one of those types will resolve to the same type as
4805 // BaseType. Therefore, just treat this as a dependent base
4806 // class initialization. FIXME: Should we try to check the
4807 // initialization anyway? It seems odd.
4808 if (ClassDecl->hasAnyDependentBases())
4809 Dependent = true;
4810 else
4811 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4812 << BaseType << Context.getCanonicalTagType(ClassDecl)
4813 << BaseTInfo->getTypeLoc().getSourceRange();
4814 }
4815 }
4816
4817 if (Dependent) {
4819
4820 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4821 /*IsVirtual=*/false,
4822 InitRange.getBegin(), Init,
4823 InitRange.getEnd(), EllipsisLoc);
4824 }
4825
4826 // C++ [base.class.init]p2:
4827 // If a mem-initializer-id is ambiguous because it designates both
4828 // a direct non-virtual base class and an inherited virtual base
4829 // class, the mem-initializer is ill-formed.
4830 if (DirectBaseSpec && VirtualBaseSpec)
4831 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4832 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4833
4834 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
4835 if (!BaseSpec)
4836 BaseSpec = VirtualBaseSpec;
4837
4838 // Initialize the base.
4839 bool InitList = true;
4840 MultiExprArg Args = Init;
4841 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4842 InitList = false;
4843 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4844 }
4845
4846 InitializedEntity BaseEntity =
4847 InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
4848 InitializationKind Kind =
4849 InitList ? InitializationKind::CreateDirectList(BaseLoc)
4850 : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
4851 InitRange.getEnd());
4852 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
4853 ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
4854 if (!BaseInit.isInvalid()) {
4855 // C++11 [class.base.init]p7:
4856 // The initialization of each base and member constitutes a
4857 // full-expression.
4858 BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin(),
4859 /*DiscardedValue*/ false);
4860 }
4861
4862 if (BaseInit.isInvalid()) {
4863 BaseInit = CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(),
4864 Args, BaseType);
4865 if (BaseInit.isInvalid())
4866 return true;
4867 } else {
4868 // If we are in a dependent context, template instantiation will
4869 // perform this type-checking again. Just save the arguments that we
4870 // received in a ParenListExpr.
4871 // FIXME: This isn't quite ideal, since our ASTs don't capture all
4872 // of the information that we have about the base
4873 // initializer. However, deconstructing the ASTs is a dicey process,
4874 // and this approach is far more likely to get the corner cases right.
4876 BaseInit = Init;
4877 }
4878
4879 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4880 BaseSpec->isVirtual(),
4881 InitRange.getBegin(),
4882 BaseInit.getAs<Expr>(),
4883 InitRange.getEnd(), EllipsisLoc);
4884}
4885
4886// Create a static_cast<T&&>(expr).
4888 QualType TargetType =
4889 SemaRef.BuildReferenceType(E->getType(), /*SpelledAsLValue*/ false,
4891 SourceLocation ExprLoc = E->getBeginLoc();
4893 TargetType, ExprLoc);
4894
4895 return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
4896 SourceRange(ExprLoc, ExprLoc),
4897 E->getSourceRange()).get();
4898}
4899
4900/// ImplicitInitializerKind - How an implicit base or member initializer should
4901/// initialize its base or member.
4908
4909static bool
4911 ImplicitInitializerKind ImplicitInitKind,
4912 CXXBaseSpecifier *BaseSpec,
4913 bool IsInheritedVirtualBase,
4914 CXXCtorInitializer *&CXXBaseInit) {
4915 InitializedEntity InitEntity
4917 IsInheritedVirtualBase);
4918
4919 ExprResult BaseInit;
4920
4921 switch (ImplicitInitKind) {
4922 case IIK_Inherit:
4923 case IIK_Default: {
4924 InitializationKind InitKind
4926 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, {});
4927 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, {});
4928 break;
4929 }
4930
4931 case IIK_Move:
4932 case IIK_Copy: {
4933 bool Moving = ImplicitInitKind == IIK_Move;
4934 ParmVarDecl *Param = Constructor->getParamDecl(0);
4935 QualType ParamType = Param->getType().getNonReferenceType();
4936
4937 Expr *CopyCtorArg =
4939 SourceLocation(), Param, false,
4940 Constructor->getLocation(), ParamType,
4941 VK_LValue, nullptr);
4942
4943 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
4944
4945 // Cast to the base class to avoid ambiguities.
4946 QualType ArgTy =
4948 ParamType.getQualifiers());
4949
4950 if (Moving) {
4951 CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
4952 }
4953
4954 CXXCastPath BasePath;
4955 BasePath.push_back(BaseSpec);
4956 CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
4957 CK_UncheckedDerivedToBase,
4958 Moving ? VK_XValue : VK_LValue,
4959 &BasePath).get();
4960
4961 InitializationKind InitKind
4964 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
4965 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
4966 break;
4967 }
4968 }
4969
4970 BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
4971 if (BaseInit.isInvalid())
4972 return true;
4973
4974 CXXBaseInit =
4977 SourceLocation()),
4978 BaseSpec->isVirtual(),
4980 BaseInit.getAs<Expr>(),
4982 SourceLocation());
4983
4984 return false;
4985}
4986
4987static bool RefersToRValueRef(Expr *MemRef) {
4988 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4989 return Referenced->getType()->isRValueReferenceType();
4990}
4991
4992static bool
4994 ImplicitInitializerKind ImplicitInitKind,
4996 CXXCtorInitializer *&CXXMemberInit) {
4997 if (Field->isInvalidDecl())
4998 return true;
4999
5000 SourceLocation Loc = Constructor->getLocation();
5001
5002 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
5003 bool Moving = ImplicitInitKind == IIK_Move;
5004 ParmVarDecl *Param = Constructor->getParamDecl(0);
5005 QualType ParamType = Param->getType().getNonReferenceType();
5006
5007 // Suppress copying zero-width bitfields.
5008 if (Field->isZeroLengthBitField())
5009 return false;
5010
5011 Expr *MemberExprBase =
5013 SourceLocation(), Param, false,
5014 Loc, ParamType, VK_LValue, nullptr);
5015
5016 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
5017
5018 if (Moving) {
5019 MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
5020 }
5021
5022 // Build a reference to this field within the parameter.
5023 CXXScopeSpec SS;
5024 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
5026 MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
5027 : cast<ValueDecl>(Field), AS_public);
5028 MemberLookup.resolveKind();
5029 ExprResult CtorArg
5030 = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
5031 ParamType, Loc,
5032 /*IsArrow=*/false,
5033 SS,
5034 /*TemplateKWLoc=*/SourceLocation(),
5035 /*FirstQualifierInScope=*/nullptr,
5036 MemberLookup,
5037 /*TemplateArgs=*/nullptr,
5038 /*S*/nullptr);
5039 if (CtorArg.isInvalid())
5040 return true;
5041
5042 // C++11 [class.copy]p15:
5043 // - if a member m has rvalue reference type T&&, it is direct-initialized
5044 // with static_cast<T&&>(x.m);
5045 if (RefersToRValueRef(CtorArg.get())) {
5046 CtorArg = CastForMoving(SemaRef, CtorArg.get());
5047 }
5048
5049 InitializedEntity Entity =
5051 /*Implicit*/ true)
5052 : InitializedEntity::InitializeMember(Field, nullptr,
5053 /*Implicit*/ true);
5054
5055 // Direct-initialize to use the copy constructor.
5056 InitializationKind InitKind =
5058
5059 Expr *CtorArgE = CtorArg.getAs<Expr>();
5060 InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
5061 ExprResult MemberInit =
5062 InitSeq.Perform(SemaRef, Entity, InitKind, MultiExprArg(&CtorArgE, 1));
5063 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
5064 if (MemberInit.isInvalid())
5065 return true;
5066
5067 if (Indirect)
5068 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
5069 SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
5070 else
5071 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
5072 SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
5073 return false;
5074 }
5075
5076 assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
5077 "Unhandled implicit init kind!");
5078
5079 QualType FieldBaseElementType =
5080 SemaRef.Context.getBaseElementType(Field->getType());
5081
5082 if (FieldBaseElementType->isRecordType()) {
5083 InitializedEntity InitEntity =
5085 /*Implicit*/ true)
5086 : InitializedEntity::InitializeMember(Field, nullptr,
5087 /*Implicit*/ true);
5088 InitializationKind InitKind =
5090
5091 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, {});
5092 ExprResult MemberInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, {});
5093
5094 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
5095 if (MemberInit.isInvalid())
5096 return true;
5097
5098 if (Indirect)
5099 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
5100 Indirect, Loc,
5101 Loc,
5102 MemberInit.get(),
5103 Loc);
5104 else
5105 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
5106 Field, Loc, Loc,
5107 MemberInit.get(),
5108 Loc);
5109 return false;
5110 }
5111
5112 if (!Field->getParent()->isUnion()) {
5113 if (FieldBaseElementType->isReferenceType()) {
5114 SemaRef.Diag(Constructor->getLocation(),
5115 diag::err_uninitialized_member_in_ctor)
5116 << (int)Constructor->isImplicit()
5117 << SemaRef.Context.getCanonicalTagType(Constructor->getParent()) << 0
5118 << Field->getDeclName();
5119 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
5120 return true;
5121 }
5122
5123 if (FieldBaseElementType.isConstQualified()) {
5124 SemaRef.Diag(Constructor->getLocation(),
5125 diag::err_uninitialized_member_in_ctor)
5126 << (int)Constructor->isImplicit()
5127 << SemaRef.Context.getCanonicalTagType(Constructor->getParent()) << 1
5128 << Field->getDeclName();
5129 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
5130 return true;
5131 }
5132 }
5133
5134 if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
5135 // ARC and Weak:
5136 // Default-initialize Objective-C pointers to NULL.
5137 CXXMemberInit
5139 Loc, Loc,
5140 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
5141 Loc);
5142 return false;
5143 }
5144
5145 // Nothing to initialize.
5146 CXXMemberInit = nullptr;
5147 return false;
5148}
5149
5150namespace {
5151struct BaseAndFieldInfo {
5152 Sema &S;
5153 CXXConstructorDecl *Ctor;
5154 bool AnyErrorsInInits;
5156 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
5158 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
5159
5160 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
5161 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
5162 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
5163 if (Ctor->getInheritedConstructor())
5164 IIK = IIK_Inherit;
5165 else if (Generated && Ctor->isCopyConstructor())
5166 IIK = IIK_Copy;
5167 else if (Generated && Ctor->isMoveConstructor())
5168 IIK = IIK_Move;
5169 else
5170 IIK = IIK_Default;
5171 }
5172
5173 bool isImplicitCopyOrMove() const {
5174 switch (IIK) {
5175 case IIK_Copy:
5176 case IIK_Move:
5177 return true;
5178
5179 case IIK_Default:
5180 case IIK_Inherit:
5181 return false;
5182 }
5183
5184 llvm_unreachable("Invalid ImplicitInitializerKind!");
5185 }
5186
5187 bool addFieldInitializer(CXXCtorInitializer *Init) {
5188 AllToInit.push_back(Init);
5189
5190 // Check whether this initializer makes the field "used".
5191 if (Init->getInit()->HasSideEffects(S.Context))
5192 S.UnusedPrivateFields.remove(Init->getAnyMember());
5193
5194 return false;
5195 }
5196
5197 bool isInactiveUnionMember(FieldDecl *Field) {
5198 RecordDecl *Record = Field->getParent();
5199 if (!Record->isUnion())
5200 return false;
5201
5202 if (FieldDecl *Active =
5203 ActiveUnionMember.lookup(Record->getCanonicalDecl()))
5204 return Active != Field->getCanonicalDecl();
5205
5206 // In an implicit copy or move constructor, ignore any in-class initializer.
5207 if (isImplicitCopyOrMove())
5208 return true;
5209
5210 // If there's no explicit initialization, the field is active only if it
5211 // has an in-class initializer...
5212 if (Field->hasInClassInitializer())
5213 return false;
5214 // ... or it's an anonymous struct or union whose class has an in-class
5215 // initializer.
5216 if (!Field->isAnonymousStructOrUnion())
5217 return true;
5218 CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
5219 return !FieldRD->hasInClassInitializer();
5220 }
5221
5222 /// Determine whether the given field is, or is within, a union member
5223 /// that is inactive (because there was an initializer given for a different
5224 /// member of the union, or because the union was not initialized at all).
5225 bool isWithinInactiveUnionMember(FieldDecl *Field,
5227 if (!Indirect)
5228 return isInactiveUnionMember(Field);
5229
5230 for (auto *C : Indirect->chain()) {
5231 FieldDecl *Field = dyn_cast<FieldDecl>(C);
5232 if (Field && isInactiveUnionMember(Field))
5233 return true;
5234 }
5235 return false;
5236 }
5237};
5238}
5239
5240/// Determine whether the given type is an incomplete or zero-lenfgth
5241/// array type.
5243 if (T->isIncompleteArrayType())
5244 return true;
5245
5246 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
5247 if (ArrayT->isZeroSize())
5248 return true;
5249
5250 T = ArrayT->getElementType();
5251 }
5252
5253 return false;
5254}
5255
5256static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
5257 FieldDecl *Field,
5258 IndirectFieldDecl *Indirect = nullptr) {
5259 if (Field->isInvalidDecl())
5260 return false;
5261
5262 // Overwhelmingly common case: we have a direct initializer for this field.
5264 Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
5265 return Info.addFieldInitializer(Init);
5266
5267 // C++11 [class.base.init]p8:
5268 // if the entity is a non-static data member that has a
5269 // brace-or-equal-initializer and either
5270 // -- the constructor's class is a union and no other variant member of that
5271 // union is designated by a mem-initializer-id or
5272 // -- the constructor's class is not a union, and, if the entity is a member
5273 // of an anonymous union, no other member of that union is designated by
5274 // a mem-initializer-id,
5275 // the entity is initialized as specified in [dcl.init].
5276 //
5277 // We also apply the same rules to handle anonymous structs within anonymous
5278 // unions.
5279 if (Info.isWithinInactiveUnionMember(Field, Indirect))
5280 return false;
5281
5282 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5283 ExprResult DIE =
5284 SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
5285 if (DIE.isInvalid())
5286 return true;
5287
5288 auto Entity = InitializedEntity::InitializeMember(Field, nullptr, true);
5289 SemaRef.checkInitializerLifetime(Entity, DIE.get());
5290
5292 if (Indirect)
5293 Init = new (SemaRef.Context)
5295 SourceLocation(), DIE.get(), SourceLocation());
5296 else
5297 Init = new (SemaRef.Context)
5299 SourceLocation(), DIE.get(), SourceLocation());
5300 return Info.addFieldInitializer(Init);
5301 }
5302
5303 // Don't initialize incomplete or zero-length arrays.
5304 if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
5305 return false;
5306
5307 // Don't try to build an implicit initializer if there were semantic
5308 // errors in any of the initializers (and therefore we might be
5309 // missing some that the user actually wrote).
5310 if (Info.AnyErrorsInInits)
5311 return false;
5312
5313 CXXCtorInitializer *Init = nullptr;
5314 if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
5315 Indirect, Init))
5316 return true;
5317
5318 if (!Init)
5319 return false;
5320
5321 return Info.addFieldInitializer(Init);
5322}
5323
5324bool
5327 assert(Initializer->isDelegatingInitializer());
5328 Constructor->setNumCtorInitializers(1);
5329 CXXCtorInitializer **initializer =
5330 new (Context) CXXCtorInitializer*[1];
5331 memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
5332 Constructor->setCtorInitializers(initializer);
5333
5334 if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
5335 MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
5336 DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
5337 }
5338
5340
5341 DiagnoseUninitializedFields(*this, Constructor);
5342
5343 return false;
5344}
5345
5348 if (Class->isInvalidDecl())
5349 return nullptr;
5350 if (Class->hasIrrelevantDestructor())
5351 return nullptr;
5352
5353 // Dtor might still be missing, e.g because it's invalid.
5354 return S.LookupDestructor(Class);
5355}
5356
5358 FieldDecl *Field) {
5359 if (Field->isInvalidDecl())
5360 return;
5361
5362 // Don't destroy incomplete or zero-length arrays.
5363 if (isIncompleteOrZeroLengthArrayType(S.Context, Field->getType()))
5364 return;
5365
5366 QualType FieldType = S.Context.getBaseElementType(Field->getType());
5367
5368 auto *FieldClassDecl = FieldType->getAsCXXRecordDecl();
5369 if (!FieldClassDecl)
5370 return;
5371
5372 // The destructor for an implicit anonymous union member is never invoked.
5373 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
5374 return;
5375
5376 auto *Dtor = LookupDestructorIfRelevant(S, FieldClassDecl);
5377 if (!Dtor)
5378 return;
5379
5380 S.CheckDestructorAccess(Field->getLocation(), Dtor,
5381 S.PDiag(diag::err_access_dtor_field)
5382 << Field->getDeclName() << FieldType);
5383
5384 S.MarkFunctionReferenced(Location, Dtor);
5385 S.DiagnoseUseOfDecl(Dtor, Location);
5386}
5387
5389 CXXRecordDecl *ClassDecl) {
5390 if (ClassDecl->isDependentContext())
5391 return;
5392
5393 // We only potentially invoke the destructors of potentially constructed
5394 // subobjects.
5395 bool VisitVirtualBases = !ClassDecl->isAbstract();
5396
5397 // If the destructor exists and has already been marked used in the MS ABI,
5398 // then virtual base destructors have already been checked and marked used.
5399 // Skip checking them again to avoid duplicate diagnostics.
5401 CXXDestructorDecl *Dtor = ClassDecl->getDestructor();
5402 if (Dtor && Dtor->isUsed())
5403 VisitVirtualBases = false;
5404 }
5405
5407
5408 // Bases.
5409 for (const auto &Base : ClassDecl->bases()) {
5410 auto *BaseClassDecl = Base.getType()->getAsCXXRecordDecl();
5411 if (!BaseClassDecl)
5412 continue;
5413
5414 // Remember direct virtual bases.
5415 if (Base.isVirtual()) {
5416 if (!VisitVirtualBases)
5417 continue;
5418 DirectVirtualBases.insert(BaseClassDecl);
5419 }
5420
5421 auto *Dtor = LookupDestructorIfRelevant(S, BaseClassDecl);
5422 if (!Dtor)
5423 continue;
5424
5425 // FIXME: caret should be on the start of the class name
5426 S.CheckDestructorAccess(Base.getBeginLoc(), Dtor,
5427 S.PDiag(diag::err_access_dtor_base)
5428 << Base.getType() << Base.getSourceRange(),
5429 S.Context.getCanonicalTagType(ClassDecl));
5430
5431 S.MarkFunctionReferenced(Location, Dtor);
5432 S.DiagnoseUseOfDecl(Dtor, Location);
5433 }
5434
5435 if (VisitVirtualBases)
5436 S.MarkVirtualBaseDestructorsReferenced(Location, ClassDecl,
5437 &DirectVirtualBases);
5438}
5439
5441 ArrayRef<CXXCtorInitializer *> Initializers) {
5442 if (Constructor->isDependentContext()) {
5443 // Just store the initializers as written, they will be checked during
5444 // instantiation.
5445 if (!Initializers.empty()) {
5446 Constructor->setNumCtorInitializers(Initializers.size());
5447 CXXCtorInitializer **baseOrMemberInitializers =
5448 new (Context) CXXCtorInitializer*[Initializers.size()];
5449 memcpy(baseOrMemberInitializers, Initializers.data(),
5450 Initializers.size() * sizeof(CXXCtorInitializer*));
5451 Constructor->setCtorInitializers(baseOrMemberInitializers);
5452 }
5453
5454 // Let template instantiation know whether we had errors.
5455 if (AnyErrors)
5456 Constructor->setInvalidDecl();
5457
5458 return false;
5459 }
5460
5461 BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
5462
5463 // We need to build the initializer AST according to order of construction
5464 // and not what user specified in the Initializers list.
5465 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5466 if (!ClassDecl)
5467 return true;
5468
5469 bool HadError = false;
5470
5471 for (unsigned i = 0; i < Initializers.size(); i++) {
5472 CXXCtorInitializer *Member = Initializers[i];
5473
5474 if (Member->isBaseInitializer())
5475 Info.AllBaseFields[Member->getBaseClass()->getAsCanonical<RecordType>()] =
5476 Member;
5477 else {
5478 Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
5479
5480 if (IndirectFieldDecl *F = Member->getIndirectMember()) {
5481 for (auto *C : F->chain()) {
5482 FieldDecl *FD = dyn_cast<FieldDecl>(C);
5483 if (FD && FD->getParent()->isUnion())
5484 Info.ActiveUnionMember.insert(std::make_pair(
5486 }
5487 } else if (FieldDecl *FD = Member->getMember()) {
5488 if (FD->getParent()->isUnion())
5489 Info.ActiveUnionMember.insert(std::make_pair(
5491 }
5492 }
5493 }
5494
5495 // Keep track of the direct virtual bases.
5497 for (auto &I : ClassDecl->bases()) {
5498 if (I.isVirtual())
5499 DirectVBases.insert(&I);
5500 }
5501
5502 // Push virtual bases before others.
5503 for (auto &VBase : ClassDecl->vbases()) {
5504 if (CXXCtorInitializer *Value = Info.AllBaseFields.lookup(
5505 VBase.getType()->getAsCanonical<RecordType>())) {
5506 // [class.base.init]p7, per DR257:
5507 // A mem-initializer where the mem-initializer-id names a virtual base
5508 // class is ignored during execution of a constructor of any class that
5509 // is not the most derived class.
5510 if (ClassDecl->isAbstract()) {
5511 // FIXME: Provide a fixit to remove the base specifier. This requires
5512 // tracking the location of the associated comma for a base specifier.
5513 Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5514 << VBase.getType() << ClassDecl;
5515 DiagnoseAbstractType(ClassDecl);
5516 }
5517
5518 Info.AllToInit.push_back(Value);
5519 } else if (!AnyErrors && !ClassDecl->isAbstract()) {
5520 // [class.base.init]p8, per DR257:
5521 // If a given [...] base class is not named by a mem-initializer-id
5522 // [...] and the entity is not a virtual base class of an abstract
5523 // class, then [...] the entity is default-initialized.
5524 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5525 CXXCtorInitializer *CXXBaseInit;
5526 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5527 &VBase, IsInheritedVirtualBase,
5528 CXXBaseInit)) {
5529 HadError = true;
5530 continue;
5531 }
5532
5533 Info.AllToInit.push_back(CXXBaseInit);
5534 }
5535 }
5536
5537 // Non-virtual bases.
5538 for (auto &Base : ClassDecl->bases()) {
5539 // Virtuals are in the virtual base list and already constructed.
5540 if (Base.isVirtual())
5541 continue;
5542
5543 if (CXXCtorInitializer *Value = Info.AllBaseFields.lookup(
5544 Base.getType()->getAsCanonical<RecordType>())) {
5545 Info.AllToInit.push_back(Value);
5546 } else if (!AnyErrors) {
5547 CXXCtorInitializer *CXXBaseInit;
5548 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5549 &Base, /*IsInheritedVirtualBase=*/false,
5550 CXXBaseInit)) {
5551 HadError = true;
5552 continue;
5553 }
5554
5555 Info.AllToInit.push_back(CXXBaseInit);
5556 }
5557 }
5558
5559 // Fields.
5560 for (auto *Mem : ClassDecl->decls()) {
5561 if (auto *F = dyn_cast<FieldDecl>(Mem)) {
5562 // C++ [class.bit]p2:
5563 // A declaration for a bit-field that omits the identifier declares an
5564 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
5565 // initialized.
5566 if (F->isUnnamedBitField())
5567 continue;
5568
5569 // If we're not generating the implicit copy/move constructor, then we'll
5570 // handle anonymous struct/union fields based on their individual
5571 // indirect fields.
5572 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5573 continue;
5574
5575 if (CollectFieldInitializer(*this, Info, F))
5576 HadError = true;
5577 continue;
5578 }
5579
5580 // Beyond this point, we only consider default initialization.
5581 if (Info.isImplicitCopyOrMove())
5582 continue;
5583
5584 if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5585 if (F->getType()->isIncompleteArrayType()) {
5586 assert(ClassDecl->hasFlexibleArrayMember() &&
5587 "Incomplete array type is not valid");
5588 continue;
5589 }
5590
5591 // Initialize each field of an anonymous struct individually.
5592 if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
5593 HadError = true;
5594
5595 continue;
5596 }
5597 }
5598
5599 unsigned NumInitializers = Info.AllToInit.size();
5600 if (NumInitializers > 0) {
5601 Constructor->setNumCtorInitializers(NumInitializers);
5602 CXXCtorInitializer **baseOrMemberInitializers =
5603 new (Context) CXXCtorInitializer*[NumInitializers];
5604 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5605 NumInitializers * sizeof(CXXCtorInitializer*));
5606 Constructor->setCtorInitializers(baseOrMemberInitializers);
5607
5608 SourceLocation Location = Constructor->getLocation();
5609
5610 // Constructors implicitly reference the base and member
5611 // destructors.
5612
5613 for (CXXCtorInitializer *Initializer : Info.AllToInit) {
5614 FieldDecl *Field = Initializer->getAnyMember();
5615 if (!Field)
5616 continue;
5617
5618 // C++ [class.base.init]p12:
5619 // In a non-delegating constructor, the destructor for each
5620 // potentially constructed subobject of class type is potentially
5621 // invoked.
5622 MarkFieldDestructorReferenced(*this, Location, Field);
5623 }
5624
5625 MarkBaseDestructorsReferenced(*this, Location, Constructor->getParent());
5626 }
5627
5628 return HadError;
5629}
5630
5632 if (const RecordType *RT = Field->getType()->getAsCanonical<RecordType>()) {
5633 const RecordDecl *RD = RT->getOriginalDecl();
5634 if (RD->isAnonymousStructOrUnion()) {
5635 for (auto *Field : RD->getDefinitionOrSelf()->fields())
5636 PopulateKeysForFields(Field, IdealInits);
5637 return;
5638 }
5639 }
5640 IdealInits.push_back(Field->getCanonicalDecl());
5641}
5642
5643static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
5644 return Context.getCanonicalType(BaseType).getTypePtr();
5645}
5646
5649 if (!Member->isAnyMemberInitializer())
5650 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
5651
5652 return Member->getAnyMember()->getCanonicalDecl();
5653}
5654
5657 const CXXCtorInitializer *Current) {
5658 if (Previous->isAnyMemberInitializer())
5659 Diag << 0 << Previous->getAnyMember();
5660 else
5661 Diag << 1 << Previous->getTypeSourceInfo()->getType();
5662
5663 if (Current->isAnyMemberInitializer())
5664 Diag << 0 << Current->getAnyMember();
5665 else
5666 Diag << 1 << Current->getTypeSourceInfo()->getType();
5667}
5668
5672 if (Constructor->getDeclContext()->isDependentContext())
5673 return;
5674
5675 // Don't check initializers order unless the warning is enabled at the
5676 // location of at least one initializer.
5677 bool ShouldCheckOrder = false;
5678 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5679 CXXCtorInitializer *Init = Inits[InitIndex];
5680 if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
5681 Init->getSourceLocation())) {
5682 ShouldCheckOrder = true;
5683 break;
5684 }
5685 }
5686 if (!ShouldCheckOrder)
5687 return;
5688
5689 // Build the list of bases and members in the order that they'll
5690 // actually be initialized. The explicit initializers should be in
5691 // this same order but may be missing things.
5692 SmallVector<const void*, 32> IdealInitKeys;
5693
5694 const CXXRecordDecl *ClassDecl = Constructor->getParent();
5695
5696 // 1. Virtual bases.
5697 for (const auto &VBase : ClassDecl->vbases())
5698 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
5699
5700 // 2. Non-virtual bases.
5701 for (const auto &Base : ClassDecl->bases()) {
5702 if (Base.isVirtual())
5703 continue;
5704 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
5705 }
5706
5707 // 3. Direct fields.
5708 for (auto *Field : ClassDecl->fields()) {
5709 if (Field->isUnnamedBitField())
5710 continue;
5711
5712 PopulateKeysForFields(Field, IdealInitKeys);
5713 }
5714
5715 unsigned NumIdealInits = IdealInitKeys.size();
5716 unsigned IdealIndex = 0;
5717
5718 // Track initializers that are in an incorrect order for either a warning or
5719 // note if multiple ones occur.
5720 SmallVector<unsigned> WarnIndexes;
5721 // Correlates the index of an initializer in the init-list to the index of
5722 // the field/base in the class.
5723 SmallVector<std::pair<unsigned, unsigned>, 32> CorrelatedInitOrder;
5724
5725 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5726 const void *InitKey = GetKeyForMember(SemaRef.Context, Inits[InitIndex]);
5727
5728 // Scan forward to try to find this initializer in the idealized
5729 // initializers list.
5730 for (; IdealIndex != NumIdealInits; ++IdealIndex)
5731 if (InitKey == IdealInitKeys[IdealIndex])
5732 break;
5733
5734 // If we didn't find this initializer, it must be because we
5735 // scanned past it on a previous iteration. That can only
5736 // happen if we're out of order; emit a warning.
5737 if (IdealIndex == NumIdealInits && InitIndex) {
5738 WarnIndexes.push_back(InitIndex);
5739
5740 // Move back to the initializer's location in the ideal list.
5741 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5742 if (InitKey == IdealInitKeys[IdealIndex])
5743 break;
5744
5745 assert(IdealIndex < NumIdealInits &&
5746 "initializer not found in initializer list");
5747 }
5748 CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
5749 }
5750
5751 if (WarnIndexes.empty())
5752 return;
5753
5754 // Sort based on the ideal order, first in the pair.
5755 llvm::sort(CorrelatedInitOrder, llvm::less_first());
5756
5757 // Introduce a new scope as SemaDiagnosticBuilder needs to be destroyed to
5758 // emit the diagnostic before we can try adding notes.
5759 {
5761 Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5762 WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5763 : diag::warn_some_initializers_out_of_order);
5764
5765 for (unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5766 if (CorrelatedInitOrder[I].second == I)
5767 continue;
5768 // Ideally we would be using InsertFromRange here, but clang doesn't
5769 // appear to handle InsertFromRange correctly when the source range is
5770 // modified by another fix-it.
5772 Inits[I]->getSourceRange(),
5775 Inits[CorrelatedInitOrder[I].second]->getSourceRange()),
5777 }
5778
5779 // If there is only 1 item out of order, the warning expects the name and
5780 // type of each being added to it.
5781 if (WarnIndexes.size() == 1) {
5782 AddInitializerToDiag(D, Inits[WarnIndexes.front() - 1],
5783 Inits[WarnIndexes.front()]);
5784 return;
5785 }
5786 }
5787 // More than 1 item to warn, create notes letting the user know which ones
5788 // are bad.
5789 for (unsigned WarnIndex : WarnIndexes) {
5790 const clang::CXXCtorInitializer *PrevInit = Inits[WarnIndex - 1];
5791 auto D = SemaRef.Diag(PrevInit->getSourceLocation(),
5792 diag::note_initializer_out_of_order);
5793 AddInitializerToDiag(D, PrevInit, Inits[WarnIndex]);
5794 D << PrevInit->getSourceRange();
5795 }
5796}
5797
5798namespace {
5799bool CheckRedundantInit(Sema &S,
5801 CXXCtorInitializer *&PrevInit) {
5802 if (!PrevInit) {
5803 PrevInit = Init;
5804 return false;
5805 }
5806
5807 if (FieldDecl *Field = Init->getAnyMember())
5808 S.Diag(Init->getSourceLocation(),
5809 diag::err_multiple_mem_initialization)
5810 << Field->getDeclName()
5811 << Init->getSourceRange();
5812 else {
5813 const Type *BaseClass = Init->getBaseClass();
5814 assert(BaseClass && "neither field nor base");
5815 S.Diag(Init->getSourceLocation(),
5816 diag::err_multiple_base_initialization)
5817 << QualType(BaseClass, 0)
5818 << Init->getSourceRange();
5819 }
5820 S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
5821 << 0 << PrevInit->getSourceRange();
5822
5823 return true;
5824}
5825
5826typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5827typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5828
5829bool CheckRedundantUnionInit(Sema &S,
5831 RedundantUnionMap &Unions) {
5832 FieldDecl *Field = Init->getAnyMember();
5833 RecordDecl *Parent = Field->getParent();
5834 NamedDecl *Child = Field;
5835
5836 while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
5837 if (Parent->isUnion()) {
5838 UnionEntry &En = Unions[Parent];
5839 if (En.first && En.first != Child) {
5840 S.Diag(Init->getSourceLocation(),
5841 diag::err_multiple_mem_union_initialization)
5842 << Field->getDeclName()
5843 << Init->getSourceRange();
5844 S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5845 << 0 << En.second->getSourceRange();
5846 return true;
5847 }
5848 if (!En.first) {
5849 En.first = Child;
5850 En.second = Init;
5851 }
5852 if (!Parent->isAnonymousStructOrUnion())
5853 return false;
5854 }
5855
5856 Child = Parent;
5857 Parent = cast<RecordDecl>(Parent->getDeclContext());
5858 }
5859
5860 return false;
5861}
5862} // namespace
5863
5864void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
5865 SourceLocation ColonLoc,
5867 bool AnyErrors) {
5868 if (!ConstructorDecl)
5869 return;
5870
5871 AdjustDeclIfTemplate(ConstructorDecl);
5872
5874 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5875
5876 if (!Constructor) {
5877 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5878 return;
5879 }
5880
5881 // Mapping for the duplicate initializers check.
5882 // For member initializers, this is keyed with a FieldDecl*.
5883 // For base initializers, this is keyed with a Type*.
5884 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5885
5886 // Mapping for the inconsistent anonymous-union initializers check.
5887 RedundantUnionMap MemberUnions;
5888
5889 bool HadError = false;
5890 for (unsigned i = 0; i < MemInits.size(); i++) {
5891 CXXCtorInitializer *Init = MemInits[i];
5892
5893 // Set the source order index.
5894 Init->setSourceOrder(i);
5895
5896 if (Init->isAnyMemberInitializer()) {
5897 const void *Key = GetKeyForMember(Context, Init);
5898 if (CheckRedundantInit(*this, Init, Members[Key]) ||
5899 CheckRedundantUnionInit(*this, Init, MemberUnions))
5900 HadError = true;
5901 } else if (Init->isBaseInitializer()) {
5902 const void *Key = GetKeyForMember(Context, Init);
5903 if (CheckRedundantInit(*this, Init, Members[Key]))
5904 HadError = true;
5905 } else {
5906 assert(Init->isDelegatingInitializer());
5907 // This must be the only initializer
5908 if (MemInits.size() != 1) {
5909 Diag(Init->getSourceLocation(),
5910 diag::err_delegating_initializer_alone)
5911 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5912 // We will treat this as being the only initializer.
5913 }
5915 // Return immediately as the initializer is set.
5916 return;
5917 }
5918 }
5919
5920 if (HadError)
5921 return;
5922
5924
5925 SetCtorInitializers(Constructor, AnyErrors, MemInits);
5926
5927 DiagnoseUninitializedFields(*this, Constructor);
5928}
5929
5931 CXXRecordDecl *ClassDecl) {
5932 // Ignore dependent contexts. Also ignore unions, since their members never
5933 // have destructors implicitly called.
5934 if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
5935 return;
5936
5937 // FIXME: all the access-control diagnostics are positioned on the
5938 // field/base declaration. That's probably good; that said, the
5939 // user might reasonably want to know why the destructor is being
5940 // emitted, and we currently don't say.
5941
5942 // Non-static data members.
5943 for (auto *Field : ClassDecl->fields()) {
5944 MarkFieldDestructorReferenced(*this, Location, Field);
5945 }
5946
5947 MarkBaseDestructorsReferenced(*this, Location, ClassDecl);
5948}
5949
5951 SourceLocation Location, CXXRecordDecl *ClassDecl,
5952 llvm::SmallPtrSetImpl<const CXXRecordDecl *> *DirectVirtualBases) {
5953 // Virtual bases.
5954 for (const auto &VBase : ClassDecl->vbases()) {
5955 auto *BaseClassDecl = VBase.getType()->getAsCXXRecordDecl();
5956 if (!BaseClassDecl)
5957 continue;
5958
5959 // Ignore already visited direct virtual bases.
5960 if (DirectVirtualBases && DirectVirtualBases->count(BaseClassDecl))
5961 continue;
5962
5963 auto *Dtor = LookupDestructorIfRelevant(*this, BaseClassDecl);
5964 if (!Dtor)
5965 continue;
5966
5967 CanQualType CT = Context.getCanonicalTagType(ClassDecl);
5968 if (CheckDestructorAccess(ClassDecl->getLocation(), Dtor,
5969 PDiag(diag::err_access_dtor_vbase)
5970 << CT << VBase.getType(),
5971 CT) == AR_accessible) {
5973 CT, VBase.getType(), diag::err_access_dtor_vbase, 0,
5974 ClassDecl->getLocation(), SourceRange(), DeclarationName(), nullptr);
5975 }
5976
5977 MarkFunctionReferenced(Location, Dtor);
5978 DiagnoseUseOfDecl(Dtor, Location);
5979 }
5980}
5981
5983 if (!CDtorDecl)
5984 return;
5985
5987 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
5988 if (CXXRecordDecl *ClassDecl = Constructor->getParent();
5989 !ClassDecl || ClassDecl->isInvalidDecl()) {
5990 return;
5991 }
5992 SetCtorInitializers(Constructor, /*AnyErrors=*/false);
5993 DiagnoseUninitializedFields(*this, Constructor);
5994 }
5995}
5996
5998 if (!getLangOpts().CPlusPlus)
5999 return false;
6000
6001 const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
6002 if (!RD)
6003 return false;
6004
6005 // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
6006 // class template specialization here, but doing so breaks a lot of code.
6007
6008 // We can't answer whether something is abstract until it has a
6009 // definition. If it's currently being defined, we'll walk back
6010 // over all the declarations when we have a full definition.
6011 const CXXRecordDecl *Def = RD->getDefinition();
6012 if (!Def || Def->isBeingDefined())
6013 return false;
6014
6015 return RD->isAbstract();
6016}
6017
6019 TypeDiagnoser &Diagnoser) {
6020 if (!isAbstractType(Loc, T))
6021 return false;
6022
6024 Diagnoser.diagnose(*this, Loc, T);
6026 return true;
6027}
6028
6030 // Check if we've already emitted the list of pure virtual functions
6031 // for this class.
6033 return;
6034
6035 // If the diagnostic is suppressed, don't emit the notes. We're only
6036 // going to emit them once, so try to attach them to a diagnostic we're
6037 // actually going to show.
6039 return;
6040
6041 CXXFinalOverriderMap FinalOverriders;
6042 RD->getFinalOverriders(FinalOverriders);
6043
6044 // Keep a set of seen pure methods so we won't diagnose the same method
6045 // more than once.
6047
6048 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
6049 MEnd = FinalOverriders.end();
6050 M != MEnd;
6051 ++M) {
6052 for (OverridingMethods::iterator SO = M->second.begin(),
6053 SOEnd = M->second.end();
6054 SO != SOEnd; ++SO) {
6055 // C++ [class.abstract]p4:
6056 // A class is abstract if it contains or inherits at least one
6057 // pure virtual function for which the final overrider is pure
6058 // virtual.
6059
6060 //
6061 if (SO->second.size() != 1)
6062 continue;
6063
6064 if (!SO->second.front().Method->isPureVirtual())
6065 continue;
6066
6067 if (!SeenPureMethods.insert(SO->second.front().Method).second)
6068 continue;
6069
6070 Diag(SO->second.front().Method->getLocation(),
6071 diag::note_pure_virtual_function)
6072 << SO->second.front().Method->getDeclName() << RD->getDeclName();
6073 }
6074 }
6075
6078 PureVirtualClassDiagSet->insert(RD);
6079}
6080
6081namespace {
6082struct AbstractUsageInfo {
6083 Sema &S;
6085 CanQualType AbstractType;
6086 bool Invalid;
6087
6088 AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
6089 : S(S), Record(Record),
6090 AbstractType(S.Context.getCanonicalTagType(Record)), Invalid(false) {}
6091
6092 void DiagnoseAbstractType() {
6093 if (Invalid) return;
6095 Invalid = true;
6096 }
6097
6098 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
6099};
6100
6101struct CheckAbstractUsage {
6102 AbstractUsageInfo &Info;
6103 const NamedDecl *Ctx;
6104
6105 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
6106 : Info(Info), Ctx(Ctx) {}
6107
6108 void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
6109 switch (TL.getTypeLocClass()) {
6110#define ABSTRACT_TYPELOC(CLASS, PARENT)
6111#define TYPELOC(CLASS, PARENT) \
6112 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
6113#include "clang/AST/TypeLocNodes.def"
6114 }
6115 }
6116
6117 void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
6119 for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
6120 if (!TL.getParam(I))
6121 continue;
6122
6124 if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
6125 }
6126 }
6127
6128 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
6130 }
6131
6133 // Visit the type parameters from a permissive context.
6134 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
6135 TemplateArgumentLoc TAL = TL.getArgLoc(I);
6137 if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
6138 Visit(TSI->getTypeLoc(), Sema::AbstractNone);
6139 // TODO: other template argument types?
6140 }
6141 }
6142
6143 // Visit pointee types from a permissive context.
6144#define CheckPolymorphic(Type) \
6145 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
6146 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
6147 }
6153
6154 /// Handle all the types we haven't given a more specific
6155 /// implementation for above.
6156 void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
6157 // Every other kind of type that we haven't called out already
6158 // that has an inner type is either (1) sugar or (2) contains that
6159 // inner type in some way as a subobject.
6160 if (TypeLoc Next = TL.getNextTypeLoc())
6161 return Visit(Next, Sel);
6162
6163 // If there's no inner type and we're in a permissive context,
6164 // don't diagnose.
6165 if (Sel == Sema::AbstractNone) return;
6166
6167 // Check whether the type matches the abstract type.
6168 QualType T = TL.getType();
6169 if (T->isArrayType()) {
6171 T = Info.S.Context.getBaseElementType(T);
6172 }
6174 if (CT != Info.AbstractType) return;
6175
6176 // It matched; do some magic.
6177 // FIXME: These should be at most warnings. See P0929R2, CWG1640, CWG1646.
6178 if (Sel == Sema::AbstractArrayType) {
6179 Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
6180 << T << TL.getSourceRange();
6181 } else {
6182 Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
6183 << Sel << T << TL.getSourceRange();
6184 }
6185 Info.DiagnoseAbstractType();
6186 }
6187};
6188
6189void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
6191 CheckAbstractUsage(*this, D).Visit(TL, Sel);
6192}
6193
6194}
6195
6196/// Check for invalid uses of an abstract type in a function declaration.
6197static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6198 FunctionDecl *FD) {
6199 // Only definitions are required to refer to complete and
6200 // non-abstract types.
6202 return;
6203
6204 // For safety's sake, just ignore it if we don't have type source
6205 // information. This should never happen for non-implicit methods,
6206 // but...
6207 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
6208 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractNone);
6209}
6210
6211/// Check for invalid uses of an abstract type in a variable0 declaration.
6212static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6213 VarDecl *VD) {
6214 // No need to do the check on definitions, which require that
6215 // the type is complete.
6217 return;
6218
6219 Info.CheckType(VD, VD->getTypeSourceInfo()->getTypeLoc(),
6221}
6222
6223/// Check for invalid uses of an abstract type within a class definition.
6224static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6225 CXXRecordDecl *RD) {
6226 for (auto *D : RD->decls()) {
6227 if (D->isImplicit()) continue;
6228
6229 // Step through friends to the befriended declaration.
6230 if (auto *FD = dyn_cast<FriendDecl>(D)) {
6231 D = FD->getFriendDecl();
6232 if (!D) continue;
6233 }
6234
6235 // Functions and function templates.
6236 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
6237 CheckAbstractClassUsage(Info, FD);
6238 } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(D)) {
6239 CheckAbstractClassUsage(Info, FTD->getTemplatedDecl());
6240
6241 // Fields and static variables.
6242 } else if (auto *FD = dyn_cast<FieldDecl>(D)) {
6243 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
6244 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
6245 } else if (auto *VD = dyn_cast<VarDecl>(D)) {
6246 CheckAbstractClassUsage(Info, VD);
6247 } else if (auto *VTD = dyn_cast<VarTemplateDecl>(D)) {
6248 CheckAbstractClassUsage(Info, VTD->getTemplatedDecl());
6249
6250 // Nested classes and class templates.
6251 } else if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
6252 CheckAbstractClassUsage(Info, RD);
6253 } else if (auto *CTD = dyn_cast<ClassTemplateDecl>(D)) {
6254 CheckAbstractClassUsage(Info, CTD->getTemplatedDecl());
6255 }
6256 }
6257}
6258
6260 Attr *ClassAttr = getDLLAttr(Class);
6261 if (!ClassAttr)
6262 return;
6263
6264 assert(ClassAttr->getKind() == attr::DLLExport);
6265
6266 TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
6267
6269 // Don't go any further if this is just an explicit instantiation
6270 // declaration.
6271 return;
6272
6273 // Add a context note to explain how we got to any diagnostics produced below.
6274 struct MarkingClassDllexported {
6275 Sema &S;
6276 MarkingClassDllexported(Sema &S, CXXRecordDecl *Class,
6277 SourceLocation AttrLoc)
6278 : S(S) {
6281 Ctx.PointOfInstantiation = AttrLoc;
6282 Ctx.Entity = Class;
6284 }
6285 ~MarkingClassDllexported() {
6287 }
6288 } MarkingDllexportedContext(S, Class, ClassAttr->getLocation());
6289
6290 if (S.Context.getTargetInfo().getTriple().isOSCygMing())
6291 S.MarkVTableUsed(Class->getLocation(), Class, true);
6292
6293 for (Decl *Member : Class->decls()) {
6294 // Skip members that were not marked exported.
6295 if (!Member->hasAttr<DLLExportAttr>())
6296 continue;
6297
6298 // Defined static variables that are members of an exported base
6299 // class must be marked export too.
6300 auto *VD = dyn_cast<VarDecl>(Member);
6301 if (VD && VD->getStorageClass() == SC_Static &&
6303 S.MarkVariableReferenced(VD->getLocation(), VD);
6304
6305 auto *MD = dyn_cast<CXXMethodDecl>(Member);
6306 if (!MD)
6307 continue;
6308
6309 if (MD->isUserProvided()) {
6310 // Instantiate non-default class member functions ...
6311
6312 // .. except for certain kinds of template specializations.
6313 if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
6314 continue;
6315
6316 // If this is an MS ABI dllexport default constructor, instantiate any
6317 // default arguments.
6319 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6320 if (CD && CD->isDefaultConstructor() && TSK == TSK_Undeclared) {
6322 }
6323 }
6324
6325 S.MarkFunctionReferenced(Class->getLocation(), MD);
6326
6327 // The function will be passed to the consumer when its definition is
6328 // encountered.
6329 } else if (MD->isExplicitlyDefaulted()) {
6330 // Synthesize and instantiate explicitly defaulted methods.
6331 S.MarkFunctionReferenced(Class->getLocation(), MD);
6332
6334 // Except for explicit instantiation defs, we will not see the
6335 // definition again later, so pass it to the consumer now.
6337 }
6338 } else if (!MD->isTrivial() ||
6339 MD->isCopyAssignmentOperator() ||
6340 MD->isMoveAssignmentOperator()) {
6341 // Synthesize and instantiate non-trivial implicit methods, and the copy
6342 // and move assignment operators. The latter are exported even if they
6343 // are trivial, because the address of an operator can be taken and
6344 // should compare equal across libraries.
6345 S.MarkFunctionReferenced(Class->getLocation(), MD);
6346
6347 // There is no later point when we will see the definition of this
6348 // function, so pass it to the consumer now.
6350 }
6351 }
6352}
6353
6356 // Only the MS ABI has default constructor closures, so we don't need to do
6357 // this semantic checking anywhere else.
6359 return;
6360
6361 CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
6362 for (Decl *Member : Class->decls()) {
6363 // Look for exported default constructors.
6364 auto *CD = dyn_cast<CXXConstructorDecl>(Member);
6365 if (!CD || !CD->isDefaultConstructor())
6366 continue;
6367 auto *Attr = CD->getAttr<DLLExportAttr>();
6368 if (!Attr)
6369 continue;
6370
6371 // If the class is non-dependent, mark the default arguments as ODR-used so
6372 // that we can properly codegen the constructor closure.
6373 if (!Class->isDependentContext()) {
6374 for (ParmVarDecl *PD : CD->parameters()) {
6375 (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD);
6377 }
6378 }
6379
6380 if (LastExportedDefaultCtor) {
6381 S.Diag(LastExportedDefaultCtor->getLocation(),
6382 diag::err_attribute_dll_ambiguous_default_ctor)
6383 << Class;
6384 S.Diag(CD->getLocation(), diag::note_entity_declared_at)
6385 << CD->getDeclName();
6386 return;
6387 }
6388 LastExportedDefaultCtor = CD;
6389 }
6390}
6391
6394 bool ErrorReported = false;
6395 auto reportIllegalClassTemplate = [&ErrorReported](Sema &S,
6396 ClassTemplateDecl *TD) {
6397 if (ErrorReported)
6398 return;
6399 S.Diag(TD->getLocation(),
6400 diag::err_cuda_device_builtin_surftex_cls_template)
6401 << /*surface*/ 0 << TD;
6402 ErrorReported = true;
6403 };
6404
6405 ClassTemplateDecl *TD = Class->getDescribedClassTemplate();
6406 if (!TD) {
6407 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(Class);
6408 if (!SD) {
6409 S.Diag(Class->getLocation(),
6410 diag::err_cuda_device_builtin_surftex_ref_decl)
6411 << /*surface*/ 0 << Class;
6412 S.Diag(Class->getLocation(),
6413 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6414 << Class;
6415 return;
6416 }
6417 TD = SD->getSpecializedTemplate();
6418 }
6419
6421 unsigned N = Params->size();
6422
6423 if (N != 2) {
6424 reportIllegalClassTemplate(S, TD);
6425 S.Diag(TD->getLocation(),
6426 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6427 << TD << 2;
6428 }
6429 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
6430 reportIllegalClassTemplate(S, TD);
6431 S.Diag(TD->getLocation(),
6432 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6433 << TD << /*1st*/ 0 << /*type*/ 0;
6434 }
6435 if (N > 1) {
6436 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(1));
6437 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6438 reportIllegalClassTemplate(S, TD);
6439 S.Diag(TD->getLocation(),
6440 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6441 << TD << /*2nd*/ 1 << /*integer*/ 1;
6442 }
6443 }
6444}
6445
6448 bool ErrorReported = false;
6449 auto reportIllegalClassTemplate = [&ErrorReported](Sema &S,
6450 ClassTemplateDecl *TD) {
6451 if (ErrorReported)
6452 return;
6453 S.Diag(TD->getLocation(),
6454 diag::err_cuda_device_builtin_surftex_cls_template)
6455 << /*texture*/ 1 << TD;
6456 ErrorReported = true;
6457 };
6458
6459 ClassTemplateDecl *TD = Class->getDescribedClassTemplate();
6460 if (!TD) {
6461 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(Class);
6462 if (!SD) {
6463 S.Diag(Class->getLocation(),
6464 diag::err_cuda_device_builtin_surftex_ref_decl)
6465 << /*texture*/ 1 << Class;
6466 S.Diag(Class->getLocation(),
6467 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6468 << Class;
6469 return;
6470 }
6471 TD = SD->getSpecializedTemplate();
6472 }
6473
6475 unsigned N = Params->size();
6476
6477 if (N != 3) {
6478 reportIllegalClassTemplate(S, TD);
6479 S.Diag(TD->getLocation(),
6480 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6481 << TD << 3;
6482 }
6483 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
6484 reportIllegalClassTemplate(S, TD);
6485 S.Diag(TD->getLocation(),
6486 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6487 << TD << /*1st*/ 0 << /*type*/ 0;
6488 }
6489 if (N > 1) {
6490 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(1));
6491 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6492 reportIllegalClassTemplate(S, TD);
6493 S.Diag(TD->getLocation(),
6494 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6495 << TD << /*2nd*/ 1 << /*integer*/ 1;
6496 }
6497 }
6498 if (N > 2) {
6499 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(2));
6500 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6501 reportIllegalClassTemplate(S, TD);
6502 S.Diag(TD->getLocation(),
6503 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6504 << TD << /*3rd*/ 2 << /*integer*/ 1;
6505 }
6506 }
6507}
6508
6510 // Mark any compiler-generated routines with the implicit code_seg attribute.
6511 for (auto *Method : Class->methods()) {
6512 if (Method->isUserProvided())
6513 continue;
6514 if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
6515 Method->addAttr(A);
6516 }
6517}
6518
6520 Attr *ClassAttr = getDLLAttr(Class);
6521
6522 // MSVC inherits DLL attributes to partial class template specializations.
6523 if (Context.getTargetInfo().shouldDLLImportComdatSymbols() && !ClassAttr) {
6524 if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
6525 if (Attr *TemplateAttr =
6526 getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
6527 auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
6528 A->setInherited(true);
6529 ClassAttr = A;
6530 }
6531 }
6532 }
6533
6534 if (!ClassAttr)
6535 return;
6536
6537 // MSVC allows imported or exported template classes that have UniqueExternal
6538 // linkage. This occurs when the template class has been instantiated with
6539 // a template parameter which itself has internal linkage.
6540 // We drop the attribute to avoid exporting or importing any members.
6542 Context.getTargetInfo().getTriple().isPS()) &&
6543 (!Class->isExternallyVisible() && Class->hasExternalFormalLinkage())) {
6544 Class->dropAttrs<DLLExportAttr, DLLImportAttr>();
6545 return;
6546 }
6547
6548 if (!Class->isExternallyVisible()) {
6549 Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
6550 << Class << ClassAttr;
6551 return;
6552 }
6553
6555 !ClassAttr->isInherited()) {
6556 // Diagnose dll attributes on members of class with dll attribute.
6557 for (Decl *Member : Class->decls()) {
6558 if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
6559 continue;
6560 InheritableAttr *MemberAttr = getDLLAttr(Member);
6561 if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
6562 continue;
6563
6564 Diag(MemberAttr->getLocation(),
6565 diag::err_attribute_dll_member_of_dll_class)
6566 << MemberAttr << ClassAttr;
6567 Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
6568 Member->setInvalidDecl();
6569 }
6570 }
6571
6572 if (Class->getDescribedClassTemplate())
6573 // Don't inherit dll attribute until the template is instantiated.
6574 return;
6575
6576 // The class is either imported or exported.
6577 const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
6578
6579 // Check if this was a dllimport attribute propagated from a derived class to
6580 // a base class template specialization. We don't apply these attributes to
6581 // static data members.
6582 const bool PropagatedImport =
6583 !ClassExported &&
6584 cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
6585
6586 TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
6587
6588 // Ignore explicit dllexport on explicit class template instantiation
6589 // declarations, except in MinGW mode.
6590 if (ClassExported && !ClassAttr->isInherited() &&
6592 !Context.getTargetInfo().getTriple().isOSCygMing()) {
6593 Class->dropAttr<DLLExportAttr>();
6594 return;
6595 }
6596
6597 // Force declaration of implicit members so they can inherit the attribute.
6599
6600 // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
6601 // seem to be true in practice?
6602
6603 for (Decl *Member : Class->decls()) {
6604 VarDecl *VD = dyn_cast<VarDecl>(Member);
6605 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
6606
6607 // Only methods and static fields inherit the attributes.
6608 if (!VD && !MD)
6609 continue;
6610
6611 if (MD) {
6612 // Don't process deleted methods.
6613 if (MD->isDeleted())
6614 continue;
6615
6616 if (MD->isInlined()) {
6617 // MinGW does not import or export inline methods. But do it for
6618 // template instantiations.
6622 continue;
6623
6624 // MSVC versions before 2015 don't export the move assignment operators
6625 // and move constructor, so don't attempt to import/export them if
6626 // we have a definition.
6627 auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
6628 if ((MD->isMoveAssignmentOperator() ||
6629 (Ctor && Ctor->isMoveConstructor())) &&
6630 !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
6631 continue;
6632
6633 // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
6634 // operator is exported anyway.
6635 if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
6636 (Ctor || isa<CXXDestructorDecl>(MD)) && MD->isTrivial())
6637 continue;
6638 }
6639 }
6640
6641 // Don't apply dllimport attributes to static data members of class template
6642 // instantiations when the attribute is propagated from a derived class.
6643 if (VD && PropagatedImport)
6644 continue;
6645
6646 if (!cast<NamedDecl>(Member)->isExternallyVisible())
6647 continue;
6648
6649 if (!getDLLAttr(Member)) {
6650 InheritableAttr *NewAttr = nullptr;
6651
6652 // Do not export/import inline function when -fno-dllexport-inlines is
6653 // passed. But add attribute for later local static var check.
6654 if (!getLangOpts().DllExportInlines && MD && MD->isInlined() &&
6657 if (ClassExported) {
6658 NewAttr = ::new (getASTContext())
6659 DLLExportStaticLocalAttr(getASTContext(), *ClassAttr);
6660 } else {
6661 NewAttr = ::new (getASTContext())
6662 DLLImportStaticLocalAttr(getASTContext(), *ClassAttr);
6663 }
6664 } else {
6665 NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6666 }
6667
6668 NewAttr->setInherited(true);
6669 Member->addAttr(NewAttr);
6670
6671 if (MD) {
6672 // Propagate DLLAttr to friend re-declarations of MD that have already
6673 // been constructed.
6674 for (FunctionDecl *FD = MD->getMostRecentDecl(); FD;
6675 FD = FD->getPreviousDecl()) {
6677 continue;
6678 assert(!getDLLAttr(FD) &&
6679 "friend re-decl should not already have a DLLAttr");
6680 NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6681 NewAttr->setInherited(true);
6682 FD->addAttr(NewAttr);
6683 }
6684 }
6685 }
6686 }
6687
6688 if (ClassExported)
6689 DelayedDllExportClasses.push_back(Class);
6690}
6691
6693 CXXRecordDecl *Class, Attr *ClassAttr,
6694 ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
6695 if (getDLLAttr(
6696 BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
6697 // If the base class template has a DLL attribute, don't try to change it.
6698 return;
6699 }
6700
6701 auto TSK = BaseTemplateSpec->getSpecializationKind();
6702 if (!getDLLAttr(BaseTemplateSpec) &&
6704 TSK == TSK_ImplicitInstantiation)) {
6705 // The template hasn't been instantiated yet (or it has, but only as an
6706 // explicit instantiation declaration or implicit instantiation, which means
6707 // we haven't codegenned any members yet), so propagate the attribute.
6708 auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6709 NewAttr->setInherited(true);
6710 BaseTemplateSpec->addAttr(NewAttr);
6711
6712 // If this was an import, mark that we propagated it from a derived class to
6713 // a base class template specialization.
6714 if (auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
6715 ImportAttr->setPropagatedToBaseTemplate();
6716
6717 // If the template is already instantiated, checkDLLAttributeRedeclaration()
6718 // needs to be run again to work see the new attribute. Otherwise this will
6719 // get run whenever the template is instantiated.
6720 if (TSK != TSK_Undeclared)
6721 checkClassLevelDLLAttribute(BaseTemplateSpec);
6722
6723 return;
6724 }
6725
6726 if (getDLLAttr(BaseTemplateSpec)) {
6727 // The template has already been specialized or instantiated with an
6728 // attribute, explicitly or through propagation. We should not try to change
6729 // it.
6730 return;
6731 }
6732
6733 // The template was previously instantiated or explicitly specialized without
6734 // a dll attribute, It's too late for us to add an attribute, so warn that
6735 // this is unsupported.
6736 Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
6737 << BaseTemplateSpec->isExplicitSpecialization();
6738 Diag(ClassAttr->getLocation(), diag::note_attribute);
6739 if (BaseTemplateSpec->isExplicitSpecialization()) {
6740 Diag(BaseTemplateSpec->getLocation(),
6741 diag::note_template_class_explicit_specialization_was_here)
6742 << BaseTemplateSpec;
6743 } else {
6744 Diag(BaseTemplateSpec->getPointOfInstantiation(),
6745 diag::note_template_class_instantiation_was_here)
6746 << BaseTemplateSpec;
6747 }
6748}
6749
6752 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
6753 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
6754 if (Ctor->isDefaultConstructor())
6756
6757 if (Ctor->isCopyConstructor())
6759
6760 if (Ctor->isMoveConstructor())
6762 }
6763
6764 if (MD->isCopyAssignmentOperator())
6766
6767 if (MD->isMoveAssignmentOperator())
6769
6770 if (isa<CXXDestructorDecl>(FD))
6772 }
6773
6774 switch (FD->getDeclName().getCXXOverloadedOperator()) {
6775 case OO_EqualEqual:
6777
6778 case OO_ExclaimEqual:
6780
6781 case OO_Spaceship:
6782 // No point allowing this if <=> doesn't exist in the current language mode.
6783 if (!getLangOpts().CPlusPlus20)
6784 break;
6786
6787 case OO_Less:
6788 case OO_LessEqual:
6789 case OO_Greater:
6790 case OO_GreaterEqual:
6791 // No point allowing this if <=> doesn't exist in the current language mode.
6792 if (!getLangOpts().CPlusPlus20)
6793 break;
6795
6796 default:
6797 break;
6798 }
6799
6800 // Not defaultable.
6801 return DefaultedFunctionKind();
6802}
6803
6805 SourceLocation DefaultLoc) {
6807 if (DFK.isComparison())
6808 return S.DefineDefaultedComparison(DefaultLoc, FD, DFK.asComparison());
6809
6810 switch (DFK.asSpecialMember()) {
6813 cast<CXXConstructorDecl>(FD));
6814 break;
6816 S.DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(FD));
6817 break;
6819 S.DefineImplicitCopyAssignment(DefaultLoc, cast<CXXMethodDecl>(FD));
6820 break;
6822 S.DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(FD));
6823 break;
6825 S.DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(FD));
6826 break;
6828 S.DefineImplicitMoveAssignment(DefaultLoc, cast<CXXMethodDecl>(FD));
6829 break;
6831 llvm_unreachable("Invalid special member.");
6832 }
6833}
6834
6835/// Determine whether a type is permitted to be passed or returned in
6836/// registers, per C++ [class.temporary]p3.
6839 if (D->isDependentType() || D->isInvalidDecl())
6840 return false;
6841
6842 // Clang <= 4 used the pre-C++11 rule, which ignores move operations.
6843 // The PS4 platform ABI follows the behavior of Clang 3.2.
6845 return !D->hasNonTrivialDestructorForCall() &&
6846 !D->hasNonTrivialCopyConstructorForCall();
6847
6848 if (CCK == TargetInfo::CCK_MicrosoftWin64) {
6849 bool CopyCtorIsTrivial = false, CopyCtorIsTrivialForCall = false;
6850 bool DtorIsTrivialForCall = false;
6851
6852 // If a class has at least one eligible, trivial copy constructor, it
6853 // is passed according to the C ABI. Otherwise, it is passed indirectly.
6854 //
6855 // Note: This permits classes with non-trivial copy or move ctors to be
6856 // passed in registers, so long as they *also* have a trivial copy ctor,
6857 // which is non-conforming.
6858 if (D->needsImplicitCopyConstructor()) {
6859 if (!D->defaultedCopyConstructorIsDeleted()) {
6860 if (D->hasTrivialCopyConstructor())
6861 CopyCtorIsTrivial = true;
6862 if (D->hasTrivialCopyConstructorForCall())
6863 CopyCtorIsTrivialForCall = true;
6864 }
6865 } else {
6866 for (const CXXConstructorDecl *CD : D->ctors()) {
6867 if (CD->isCopyConstructor() && !CD->isDeleted() &&
6868 !CD->isIneligibleOrNotSelected()) {
6869 if (CD->isTrivial())
6870 CopyCtorIsTrivial = true;
6871 if (CD->isTrivialForCall())
6872 CopyCtorIsTrivialForCall = true;
6873 }
6874 }
6875 }
6876
6877 if (D->needsImplicitDestructor()) {
6878 if (!D->defaultedDestructorIsDeleted() &&
6879 D->hasTrivialDestructorForCall())
6880 DtorIsTrivialForCall = true;
6881 } else if (const auto *DD = D->getDestructor()) {
6882 if (!DD->isDeleted() && DD->isTrivialForCall())
6883 DtorIsTrivialForCall = true;
6884 }
6885
6886 // If the copy ctor and dtor are both trivial-for-calls, pass direct.
6887 if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6888 return true;
6889
6890 // If a class has a destructor, we'd really like to pass it indirectly
6891 // because it allows us to elide copies. Unfortunately, MSVC makes that
6892 // impossible for small types, which it will pass in a single register or
6893 // stack slot. Most objects with dtors are large-ish, so handle that early.
6894 // We can't call out all large objects as being indirect because there are
6895 // multiple x64 calling conventions and the C++ ABI code shouldn't dictate
6896 // how we pass large POD types.
6897
6898 // Note: This permits small classes with nontrivial destructors to be
6899 // passed in registers, which is non-conforming.
6900 bool isAArch64 = S.Context.getTargetInfo().getTriple().isAArch64();
6901 uint64_t TypeSize = isAArch64 ? 128 : 64;
6902
6903 if (CopyCtorIsTrivial && S.getASTContext().getTypeSize(
6904 S.Context.getCanonicalTagType(D)) <= TypeSize)
6905 return true;
6906 return false;
6907 }
6908
6909 // Per C++ [class.temporary]p3, the relevant condition is:
6910 // each copy constructor, move constructor, and destructor of X is
6911 // either trivial or deleted, and X has at least one non-deleted copy
6912 // or move constructor
6913 bool HasNonDeletedCopyOrMove = false;
6914
6915 if (D->needsImplicitCopyConstructor() &&
6916 !D->defaultedCopyConstructorIsDeleted()) {
6917 if (!D->hasTrivialCopyConstructorForCall())
6918 return false;
6919 HasNonDeletedCopyOrMove = true;
6920 }
6921
6922 if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor() &&
6923 !D->defaultedMoveConstructorIsDeleted()) {
6924 if (!D->hasTrivialMoveConstructorForCall())
6925 return false;
6926 HasNonDeletedCopyOrMove = true;
6927 }
6928
6929 if (D->needsImplicitDestructor() && !D->defaultedDestructorIsDeleted() &&
6930 !D->hasTrivialDestructorForCall())
6931 return false;
6932
6933 for (const CXXMethodDecl *MD : D->methods()) {
6934 if (MD->isDeleted() || MD->isIneligibleOrNotSelected())
6935 continue;
6936
6937 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6938 if (CD && CD->isCopyOrMoveConstructor())
6939 HasNonDeletedCopyOrMove = true;
6940 else if (!isa<CXXDestructorDecl>(MD))
6941 continue;
6942
6943 if (!MD->isTrivialForCall())
6944 return false;
6945 }
6946
6947 return HasNonDeletedCopyOrMove;
6948}
6949
6950/// Report an error regarding overriding, along with any relevant
6951/// overridden methods.
6952///
6953/// \param DiagID the primary error to report.
6954/// \param MD the overriding method.
6955static bool
6956ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD,
6957 llvm::function_ref<bool(const CXXMethodDecl *)> Report) {
6958 bool IssuedDiagnostic = false;
6959 for (const CXXMethodDecl *O : MD->overridden_methods()) {
6960 if (Report(O)) {
6961 if (!IssuedDiagnostic) {
6962 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
6963 IssuedDiagnostic = true;
6964 }
6965 S.Diag(O->getLocation(), diag::note_overridden_virtual_function);
6966 }
6967 }
6968 return IssuedDiagnostic;
6969}
6970
6972 if (!Record)
6973 return;
6974
6975 if (Record->isAbstract() && !Record->isInvalidDecl()) {
6976 AbstractUsageInfo Info(*this, Record);
6978 }
6979
6980 // If this is not an aggregate type and has no user-declared constructor,
6981 // complain about any non-static data members of reference or const scalar
6982 // type, since they will never get initializers.
6983 if (!Record->isInvalidDecl() && !Record->isDependentType() &&
6984 !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
6985 !Record->isLambda()) {
6986 bool Complained = false;
6987 for (const auto *F : Record->fields()) {
6988 if (F->hasInClassInitializer() || F->isUnnamedBitField())
6989 continue;
6990
6991 if (F->getType()->isReferenceType() ||
6992 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
6993 if (!Complained) {
6994 Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
6995 << Record->getTagKind() << Record;
6996 Complained = true;
6997 }
6998
6999 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
7000 << F->getType()->isReferenceType()
7001 << F->getDeclName();
7002 }
7003 }
7004 }
7005
7006 if (Record->getIdentifier()) {
7007 // C++ [class.mem]p13:
7008 // If T is the name of a class, then each of the following shall have a
7009 // name different from T:
7010 // - every member of every anonymous union that is a member of class T.
7011 //
7012 // C++ [class.mem]p14:
7013 // In addition, if class T has a user-declared constructor (12.1), every
7014 // non-static data member of class T shall have a name different from T.
7015 DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
7016 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
7017 ++I) {
7018 NamedDecl *D = (*I)->getUnderlyingDecl();
7019 // Invalid IndirectFieldDecls have already been diagnosed with
7020 // err_anonymous_record_member_redecl in
7021 // SemaDecl.cpp:CheckAnonMemberRedeclaration.
7022 if (((isa<FieldDecl>(D) || isa<UnresolvedUsingValueDecl>(D)) &&
7023 Record->hasUserDeclaredConstructor()) ||
7024 (isa<IndirectFieldDecl>(D) && !D->isInvalidDecl())) {
7025 Diag((*I)->getLocation(), diag::err_member_name_of_class)
7026 << D->getDeclName();
7027 break;
7028 }
7029 }
7030 }
7031
7032 // Warn if the class has virtual methods but non-virtual public destructor.
7033 if (Record->isPolymorphic() && !Record->isDependentType()) {
7034 CXXDestructorDecl *dtor = Record->getDestructor();
7035 if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
7036 !Record->hasAttr<FinalAttr>())
7037 Diag(dtor ? dtor->getLocation() : Record->getLocation(),
7038 diag::warn_non_virtual_dtor)
7040 }
7041
7042 if (Record->isAbstract()) {
7043 if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
7044 Diag(Record->getLocation(), diag::warn_abstract_final_class)
7045 << FA->isSpelledAsSealed();
7047 }
7048 }
7049
7050 // Warn if the class has a final destructor but is not itself marked final.
7051 if (!Record->hasAttr<FinalAttr>()) {
7052 if (const CXXDestructorDecl *dtor = Record->getDestructor()) {
7053 if (const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
7054 Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
7055 << FA->isSpelledAsSealed()
7057 getLocForEndOfToken(Record->getLocation()),
7058 (FA->isSpelledAsSealed() ? " sealed" : " final"));
7059 Diag(Record->getLocation(),
7060 diag::note_final_dtor_non_final_class_silence)
7061 << Context.getCanonicalTagType(Record) << FA->isSpelledAsSealed();
7062 }
7063 }
7064 }
7065
7066 // See if trivial_abi has to be dropped.
7067 if (Record->hasAttr<TrivialABIAttr>())
7069
7070 // Set HasTrivialSpecialMemberForCall if the record has attribute
7071 // "trivial_abi".
7072 bool HasTrivialABI = Record->hasAttr<TrivialABIAttr>();
7073
7074 if (HasTrivialABI)
7075 Record->setHasTrivialSpecialMemberForCall();
7076
7077 // Explicitly-defaulted secondary comparison functions (!=, <, <=, >, >=).
7078 // We check these last because they can depend on the properties of the
7079 // primary comparison functions (==, <=>).
7080 llvm::SmallVector<FunctionDecl*, 5> DefaultedSecondaryComparisons;
7081
7082 // Perform checks that can't be done until we know all the properties of a
7083 // member function (whether it's defaulted, deleted, virtual, overriding,
7084 // ...).
7085 auto CheckCompletedMemberFunction = [&](CXXMethodDecl *MD) {
7086 // A static function cannot override anything.
7087 if (MD->getStorageClass() == SC_Static) {
7088 if (ReportOverrides(*this, diag::err_static_overrides_virtual, MD,
7089 [](const CXXMethodDecl *) { return true; }))
7090 return;
7091 }
7092
7093 // A deleted function cannot override a non-deleted function and vice
7094 // versa.
7095 if (ReportOverrides(*this,
7096 MD->isDeleted() ? diag::err_deleted_override
7097 : diag::err_non_deleted_override,
7098 MD, [&](const CXXMethodDecl *V) {
7099 return MD->isDeleted() != V->isDeleted();
7100 })) {
7101 if (MD->isDefaulted() && MD->isDeleted())
7102 // Explain why this defaulted function was deleted.
7104 return;
7105 }
7106
7107 // A consteval function cannot override a non-consteval function and vice
7108 // versa.
7109 if (ReportOverrides(*this,
7110 MD->isConsteval() ? diag::err_consteval_override
7111 : diag::err_non_consteval_override,
7112 MD, [&](const CXXMethodDecl *V) {
7113 return MD->isConsteval() != V->isConsteval();
7114 })) {
7115 if (MD->isDefaulted() && MD->isDeleted())
7116 // Explain why this defaulted function was deleted.
7118 return;
7119 }
7120 };
7121
7122 auto CheckForDefaultedFunction = [&](FunctionDecl *FD) -> bool {
7123 if (!FD || FD->isInvalidDecl() || !FD->isExplicitlyDefaulted())
7124 return false;
7125
7129 DefaultedSecondaryComparisons.push_back(FD);
7130 return true;
7131 }
7132
7134 return false;
7135 };
7136
7137 if (!Record->isInvalidDecl() &&
7138 Record->hasAttr<VTablePointerAuthenticationAttr>())
7140
7141 auto CompleteMemberFunction = [&](CXXMethodDecl *M) {
7142 // Check whether the explicitly-defaulted members are valid.
7143 bool Incomplete = CheckForDefaultedFunction(M);
7144
7145 // Skip the rest of the checks for a member of a dependent class.
7146 if (Record->isDependentType())
7147 return;
7148
7149 // For an explicitly defaulted or deleted special member, we defer
7150 // determining triviality until the class is complete. That time is now!
7152 if (!M->isImplicit() && !M->isUserProvided()) {
7153 if (CSM != CXXSpecialMemberKind::Invalid) {
7154 M->setTrivial(SpecialMemberIsTrivial(M, CSM));
7155 // Inform the class that we've finished declaring this member.
7156 Record->finishedDefaultedOrDeletedMember(M);
7157 M->setTrivialForCall(
7158 HasTrivialABI ||
7161 Record->setTrivialForCallFlags(M);
7162 }
7163 }
7164
7165 // Set triviality for the purpose of calls if this is a user-provided
7166 // copy/move constructor or destructor.
7170 M->isUserProvided()) {
7171 M->setTrivialForCall(HasTrivialABI);
7172 Record->setTrivialForCallFlags(M);
7173 }
7174
7175 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
7176 M->hasAttr<DLLExportAttr>()) {
7177 if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
7178 M->isTrivial() &&
7182 M->dropAttr<DLLExportAttr>();
7183
7184 if (M->hasAttr<DLLExportAttr>()) {
7185 // Define after any fields with in-class initializers have been parsed.
7187 }
7188 }
7189
7190 bool EffectivelyConstexprDestructor = true;
7191 // Avoid triggering vtable instantiation due to a dtor that is not
7192 // "effectively constexpr" for better compatibility.
7193 // See https://github.com/llvm/llvm-project/issues/102293 for more info.
7194 if (isa<CXXDestructorDecl>(M)) {
7195 llvm::SmallDenseSet<QualType> Visited;
7196 auto Check = [&Visited](QualType T, auto &&Check) -> bool {
7197 if (!Visited.insert(T->getCanonicalTypeUnqualified()).second)
7198 return false;
7199 const CXXRecordDecl *RD =
7201 if (!RD || !RD->isCompleteDefinition())
7202 return true;
7203
7204 if (!RD->hasConstexprDestructor())
7205 return false;
7206
7207 for (const CXXBaseSpecifier &B : RD->bases())
7208 if (!Check(B.getType(), Check))
7209 return false;
7210 for (const FieldDecl *FD : RD->fields())
7211 if (!Check(FD->getType(), Check))
7212 return false;
7213 return true;
7214 };
7215 EffectivelyConstexprDestructor =
7216 Check(Context.getCanonicalTagType(Record), Check);
7217 }
7218
7219 // Define defaulted constexpr virtual functions that override a base class
7220 // function right away.
7221 // FIXME: We can defer doing this until the vtable is marked as used.
7222 if (CSM != CXXSpecialMemberKind::Invalid && !M->isDeleted() &&
7223 M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods() &&
7224 EffectivelyConstexprDestructor)
7225 DefineDefaultedFunction(*this, M, M->getLocation());
7226
7227 if (!Incomplete)
7228 CheckCompletedMemberFunction(M);
7229 };
7230
7231 // Check the destructor before any other member function. We need to
7232 // determine whether it's trivial in order to determine whether the claas
7233 // type is a literal type, which is a prerequisite for determining whether
7234 // other special member functions are valid and whether they're implicitly
7235 // 'constexpr'.
7236 if (CXXDestructorDecl *Dtor = Record->getDestructor())
7237 CompleteMemberFunction(Dtor);
7238
7239 bool HasMethodWithOverrideControl = false,
7240 HasOverridingMethodWithoutOverrideControl = false;
7241 for (auto *D : Record->decls()) {
7242 if (auto *M = dyn_cast<CXXMethodDecl>(D)) {
7243 // FIXME: We could do this check for dependent types with non-dependent
7244 // bases.
7245 if (!Record->isDependentType()) {
7246 // See if a method overloads virtual methods in a base
7247 // class without overriding any.
7248 if (!M->isStatic())
7250
7251 if (M->hasAttr<OverrideAttr>()) {
7252 HasMethodWithOverrideControl = true;
7253 } else if (M->size_overridden_methods() > 0) {
7254 HasOverridingMethodWithoutOverrideControl = true;
7255 } else {
7256 // Warn on newly-declared virtual methods in `final` classes
7257 if (M->isVirtualAsWritten() && Record->isEffectivelyFinal()) {
7258 Diag(M->getLocation(), diag::warn_unnecessary_virtual_specifier)
7259 << M;
7260 }
7261 }
7262 }
7263
7264 if (!isa<CXXDestructorDecl>(M))
7265 CompleteMemberFunction(M);
7266 } else if (auto *F = dyn_cast<FriendDecl>(D)) {
7267 CheckForDefaultedFunction(
7268 dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));
7269 }
7270 }
7271
7272 if (HasOverridingMethodWithoutOverrideControl) {
7273 bool HasInconsistentOverrideControl = HasMethodWithOverrideControl;
7274 for (auto *M : Record->methods())
7275 DiagnoseAbsenceOfOverrideControl(M, HasInconsistentOverrideControl);
7276 }
7277
7278 // Check the defaulted secondary comparisons after any other member functions.
7279 for (FunctionDecl *FD : DefaultedSecondaryComparisons) {
7281
7282 // If this is a member function, we deferred checking it until now.
7283 if (auto *MD = dyn_cast<CXXMethodDecl>(FD))
7284 CheckCompletedMemberFunction(MD);
7285 }
7286
7287 // ms_struct is a request to use the same ABI rules as MSVC. Check
7288 // whether this class uses any C++ features that are implemented
7289 // completely differently in MSVC, and if so, emit a diagnostic.
7290 // That diagnostic defaults to an error, but we allow projects to
7291 // map it down to a warning (or ignore it). It's a fairly common
7292 // practice among users of the ms_struct pragma to mass-annotate
7293 // headers, sweeping up a bunch of types that the project doesn't
7294 // really rely on MSVC-compatible layout for. We must therefore
7295 // support "ms_struct except for C++ stuff" as a secondary ABI.
7296 // Don't emit this diagnostic if the feature was enabled as a
7297 // language option (as opposed to via a pragma or attribute), as
7298 // the option -mms-bitfields otherwise essentially makes it impossible
7299 // to build C++ code, unless this diagnostic is turned off.
7300 if (Record->isMsStruct(Context) && !Context.getLangOpts().MSBitfields &&
7301 (Record->isPolymorphic() || Record->getNumBases())) {
7302 Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
7303 }
7304
7307
7308 bool ClangABICompat4 =
7309 Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver4;
7311 Context.getTargetInfo().getCallingConvKind(ClangABICompat4);
7312 bool CanPass = canPassInRegisters(*this, Record, CCK);
7313
7314 // Do not change ArgPassingRestrictions if it has already been set to
7315 // RecordArgPassingKind::CanNeverPassInRegs.
7316 if (Record->getArgPassingRestrictions() !=
7318 Record->setArgPassingRestrictions(
7321
7322 // If canPassInRegisters returns true despite the record having a non-trivial
7323 // destructor, the record is destructed in the callee. This happens only when
7324 // the record or one of its subobjects has a field annotated with trivial_abi
7325 // or a field qualified with ObjC __strong/__weak.
7327 Record->setParamDestroyedInCallee(true);
7328 else if (Record->hasNonTrivialDestructor())
7329 Record->setParamDestroyedInCallee(CanPass);
7330
7331 if (getLangOpts().ForceEmitVTables) {
7332 // If we want to emit all the vtables, we need to mark it as used. This
7333 // is especially required for cases like vtable assumption loads.
7334 MarkVTableUsed(Record->getInnerLocStart(), Record);
7335 }
7336
7337 if (getLangOpts().CUDA) {
7338 if (Record->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())
7340 else if (Record->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())
7342 }
7343
7344 llvm::SmallDenseMap<OverloadedOperatorKind,
7346 TypeAwareDecls{{OO_New, {}},
7347 {OO_Array_New, {}},
7348 {OO_Delete, {}},
7349 {OO_Array_New, {}}};
7350 for (auto *D : Record->decls()) {
7351 const FunctionDecl *FnDecl = D->getAsFunction();
7352 if (!FnDecl || !FnDecl->isTypeAwareOperatorNewOrDelete())
7353 continue;
7354 assert(FnDecl->getDeclName().isAnyOperatorNewOrDelete());
7355 TypeAwareDecls[FnDecl->getOverloadedOperator()].push_back(FnDecl);
7356 }
7357 auto CheckMismatchedTypeAwareAllocators =
7358 [this, &TypeAwareDecls, Record](OverloadedOperatorKind NewKind,
7359 OverloadedOperatorKind DeleteKind) {
7360 auto &NewDecls = TypeAwareDecls[NewKind];
7361 auto &DeleteDecls = TypeAwareDecls[DeleteKind];
7362 if (NewDecls.empty() == DeleteDecls.empty())
7363 return;
7364 DeclarationName FoundOperator =
7366 NewDecls.empty() ? DeleteKind : NewKind);
7367 DeclarationName MissingOperator =
7369 NewDecls.empty() ? NewKind : DeleteKind);
7370 Diag(Record->getLocation(),
7371 diag::err_type_aware_allocator_missing_matching_operator)
7372 << FoundOperator << Context.getCanonicalTagType(Record)
7373 << MissingOperator;
7374 for (auto MD : NewDecls)
7375 Diag(MD->getLocation(),
7376 diag::note_unmatched_type_aware_allocator_declared)
7377 << MD;
7378 for (auto MD : DeleteDecls)
7379 Diag(MD->getLocation(),
7380 diag::note_unmatched_type_aware_allocator_declared)
7381 << MD;
7382 };
7383 CheckMismatchedTypeAwareAllocators(OO_New, OO_Delete);
7384 CheckMismatchedTypeAwareAllocators(OO_Array_New, OO_Array_Delete);
7385}
7386
7387/// Look up the special member function that would be called by a special
7388/// member function for a subobject of class type.
7389///
7390/// \param Class The class type of the subobject.
7391/// \param CSM The kind of special member function.
7392/// \param FieldQuals If the subobject is a field, its cv-qualifiers.
7393/// \param ConstRHS True if this is a copy operation with a const object
7394/// on its RHS, that is, if the argument to the outer special member
7395/// function is 'const' and this is not a field marked 'mutable'.
7398 CXXSpecialMemberKind CSM, unsigned FieldQuals,
7399 bool ConstRHS) {
7400 unsigned LHSQuals = 0;
7403 LHSQuals = FieldQuals;
7404
7405 unsigned RHSQuals = FieldQuals;
7408 RHSQuals = 0;
7409 else if (ConstRHS)
7410 RHSQuals |= Qualifiers::Const;
7411
7412 return S.LookupSpecialMember(Class, CSM,
7413 RHSQuals & Qualifiers::Const,
7414 RHSQuals & Qualifiers::Volatile,
7415 false,
7416 LHSQuals & Qualifiers::Const,
7417 LHSQuals & Qualifiers::Volatile);
7418}
7419
7421 Sema &S;
7422 SourceLocation UseLoc;
7423
7424 /// A mapping from the base classes through which the constructor was
7425 /// inherited to the using shadow declaration in that base class (or a null
7426 /// pointer if the constructor was declared in that base class).
7427 llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
7428 InheritedFromBases;
7429
7430public:
7433 : S(S), UseLoc(UseLoc) {
7434 bool DiagnosedMultipleConstructedBases = false;
7435 CXXRecordDecl *ConstructedBase = nullptr;
7436 BaseUsingDecl *ConstructedBaseIntroducer = nullptr;
7437
7438 // Find the set of such base class subobjects and check that there's a
7439 // unique constructed subobject.
7440 for (auto *D : Shadow->redecls()) {
7441 auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
7442 auto *DNominatedBase = DShadow->getNominatedBaseClass();
7443 auto *DConstructedBase = DShadow->getConstructedBaseClass();
7444
7445 InheritedFromBases.insert(
7446 std::make_pair(DNominatedBase->getCanonicalDecl(),
7447 DShadow->getNominatedBaseClassShadowDecl()));
7448 if (DShadow->constructsVirtualBase())
7449 InheritedFromBases.insert(
7450 std::make_pair(DConstructedBase->getCanonicalDecl(),
7451 DShadow->getConstructedBaseClassShadowDecl()));
7452 else
7453 assert(DNominatedBase == DConstructedBase);
7454
7455 // [class.inhctor.init]p2:
7456 // If the constructor was inherited from multiple base class subobjects
7457 // of type B, the program is ill-formed.
7458 if (!ConstructedBase) {
7459 ConstructedBase = DConstructedBase;
7460 ConstructedBaseIntroducer = D->getIntroducer();
7461 } else if (ConstructedBase != DConstructedBase &&
7462 !Shadow->isInvalidDecl()) {
7463 if (!DiagnosedMultipleConstructedBases) {
7464 S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
7465 << Shadow->getTargetDecl();
7466 S.Diag(ConstructedBaseIntroducer->getLocation(),
7467 diag::note_ambiguous_inherited_constructor_using)
7468 << ConstructedBase;
7469 DiagnosedMultipleConstructedBases = true;
7470 }
7471 S.Diag(D->getIntroducer()->getLocation(),
7472 diag::note_ambiguous_inherited_constructor_using)
7473 << DConstructedBase;
7474 }
7475 }
7476
7477 if (DiagnosedMultipleConstructedBases)
7478 Shadow->setInvalidDecl();
7479 }
7480
7481 /// Find the constructor to use for inherited construction of a base class,
7482 /// and whether that base class constructor inherits the constructor from a
7483 /// virtual base class (in which case it won't actually invoke it).
7484 std::pair<CXXConstructorDecl *, bool>
7486 auto It = InheritedFromBases.find(Base->getCanonicalDecl());
7487 if (It == InheritedFromBases.end())
7488 return std::make_pair(nullptr, false);
7489
7490 // This is an intermediary class.
7491 if (It->second)
7492 return std::make_pair(
7493 S.findInheritingConstructor(UseLoc, Ctor, It->second),
7494 It->second->constructsVirtualBase());
7495
7496 // This is the base class from which the constructor was inherited.
7497 return std::make_pair(Ctor, false);
7498 }
7499};
7500
7501/// Is the special member function which would be selected to perform the
7502/// specified operation on the specified class type a constexpr constructor?
7504 Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, unsigned Quals,
7505 bool ConstRHS, CXXConstructorDecl *InheritedCtor = nullptr,
7506 Sema::InheritedConstructorInfo *Inherited = nullptr) {
7507 // Suppress duplicate constraint checking here, in case a constraint check
7508 // caused us to decide to do this. Any truely recursive checks will get
7509 // caught during these checks anyway.
7511
7512 // If we're inheriting a constructor, see if we need to call it for this base
7513 // class.
7514 if (InheritedCtor) {
7516 auto BaseCtor =
7517 Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
7518 if (BaseCtor)
7519 return BaseCtor->isConstexpr();
7520 }
7521
7523 return ClassDecl->hasConstexprDefaultConstructor();
7525 return ClassDecl->hasConstexprDestructor();
7526
7528 lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
7529 if (!SMOR.getMethod())
7530 // A constructor we wouldn't select can't be "involved in initializing"
7531 // anything.
7532 return true;
7533 return SMOR.getMethod()->isConstexpr();
7534}
7535
7536/// Determine whether the specified special member function would be constexpr
7537/// if it were implicitly defined.
7539 Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, bool ConstArg,
7540 CXXConstructorDecl *InheritedCtor = nullptr,
7541 Sema::InheritedConstructorInfo *Inherited = nullptr) {
7542 if (!S.getLangOpts().CPlusPlus11)
7543 return false;
7544
7545 // C++11 [dcl.constexpr]p4:
7546 // In the definition of a constexpr constructor [...]
7547 bool Ctor = true;
7548 switch (CSM) {
7550 if (Inherited)
7551 break;
7552 // Since default constructor lookup is essentially trivial (and cannot
7553 // involve, for instance, template instantiation), we compute whether a
7554 // defaulted default constructor is constexpr directly within CXXRecordDecl.
7555 //
7556 // This is important for performance; we need to know whether the default
7557 // constructor is constexpr to determine whether the type is a literal type.
7558 return ClassDecl->defaultedDefaultConstructorIsConstexpr();
7559
7562 // For copy or move constructors, we need to perform overload resolution.
7563 break;
7564
7567 if (!S.getLangOpts().CPlusPlus14)
7568 return false;
7569 // In C++1y, we need to perform overload resolution.
7570 Ctor = false;
7571 break;
7572
7574 return ClassDecl->defaultedDestructorIsConstexpr();
7575
7577 return false;
7578 }
7579
7580 // -- if the class is a non-empty union, or for each non-empty anonymous
7581 // union member of a non-union class, exactly one non-static data member
7582 // shall be initialized; [DR1359]
7583 //
7584 // If we squint, this is guaranteed, since exactly one non-static data member
7585 // will be initialized (if the constructor isn't deleted), we just don't know
7586 // which one.
7587 if (Ctor && ClassDecl->isUnion())
7589 ? ClassDecl->hasInClassInitializer() ||
7590 !ClassDecl->hasVariantMembers()
7591 : true;
7592
7593 // -- the class shall not have any virtual base classes;
7594 if (Ctor && ClassDecl->getNumVBases())
7595 return false;
7596
7597 // C++1y [class.copy]p26:
7598 // -- [the class] is a literal type, and
7599 if (!Ctor && !ClassDecl->isLiteral() && !S.getLangOpts().CPlusPlus23)
7600 return false;
7601
7602 // -- every constructor involved in initializing [...] base class
7603 // sub-objects shall be a constexpr constructor;
7604 // -- the assignment operator selected to copy/move each direct base
7605 // class is a constexpr function, and
7606 if (!S.getLangOpts().CPlusPlus23) {
7607 for (const auto &B : ClassDecl->bases()) {
7608 auto *BaseClassDecl = B.getType()->getAsCXXRecordDecl();
7609 if (!BaseClassDecl)
7610 continue;
7611 if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg,
7612 InheritedCtor, Inherited))
7613 return false;
7614 }
7615 }
7616
7617 // -- every constructor involved in initializing non-static data members
7618 // [...] shall be a constexpr constructor;
7619 // -- every non-static data member and base class sub-object shall be
7620 // initialized
7621 // -- for each non-static data member of X that is of class type (or array
7622 // thereof), the assignment operator selected to copy/move that member is
7623 // a constexpr function
7624 if (!S.getLangOpts().CPlusPlus23) {
7625 for (const auto *F : ClassDecl->fields()) {
7626 if (F->isInvalidDecl())
7627 continue;
7629 F->hasInClassInitializer())
7630 continue;
7631 QualType BaseType = S.Context.getBaseElementType(F->getType());
7632 if (const RecordType *RecordTy = BaseType->getAsCanonical<RecordType>()) {
7633 CXXRecordDecl *FieldRecDecl =
7634 cast<CXXRecordDecl>(RecordTy->getOriginalDecl())
7636 if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
7637 BaseType.getCVRQualifiers(),
7638 ConstArg && !F->isMutable()))
7639 return false;
7640 } else if (CSM == CXXSpecialMemberKind::DefaultConstructor) {
7641 return false;
7642 }
7643 }
7644 }
7645
7646 // All OK, it's constexpr!
7647 return true;
7648}
7649
7650namespace {
7651/// RAII object to register a defaulted function as having its exception
7652/// specification computed.
7653struct ComputingExceptionSpec {
7654 Sema &S;
7655
7656 ComputingExceptionSpec(Sema &S, FunctionDecl *FD, SourceLocation Loc)
7657 : S(S) {
7660 Ctx.PointOfInstantiation = Loc;
7661 Ctx.Entity = FD;
7663 }
7664 ~ComputingExceptionSpec() {
7666 }
7667};
7668}
7669
7672 CXXMethodDecl *MD,
7675
7678 FunctionDecl *FD,
7680
7683 auto DFK = S.getDefaultedFunctionKind(FD);
7684 if (DFK.isSpecialMember())
7686 S, Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(), nullptr);
7687 if (DFK.isComparison())
7689 DFK.asComparison());
7690
7691 auto *CD = cast<CXXConstructorDecl>(FD);
7692 assert(CD->getInheritedConstructor() &&
7693 "only defaulted functions and inherited constructors have implicit "
7694 "exception specs");
7696 S, Loc, CD->getInheritedConstructor().getShadowDecl());
7699}
7700
7702 CXXMethodDecl *MD) {
7704
7705 // Build an exception specification pointing back at this member.
7707 EPI.ExceptionSpec.SourceDecl = MD;
7708
7709 // Set the calling convention to the default for C++ instance methods.
7711 S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
7712 /*IsCXXMethod=*/true));
7713 return EPI;
7714}
7715
7717 const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
7719 return;
7720
7721 // Evaluate the exception specification.
7722 auto IES = computeImplicitExceptionSpec(*this, Loc, FD);
7723 auto ESI = IES.getExceptionSpec();
7724
7725 // Update the type of the special member to use it.
7726 UpdateExceptionSpec(FD, ESI);
7727}
7728
7730 assert(FD->isExplicitlyDefaulted() && "not explicitly-defaulted");
7731
7733 if (!DefKind) {
7734 assert(FD->getDeclContext()->isDependentContext());
7735 return;
7736 }
7737
7738 if (DefKind.isComparison()) {
7739 auto PT = FD->getParamDecl(0)->getType();
7740 if (const CXXRecordDecl *RD =
7741 PT.getNonReferenceType()->getAsCXXRecordDecl()) {
7742 for (FieldDecl *Field : RD->fields()) {
7743 UnusedPrivateFields.remove(Field);
7744 }
7745 }
7746 }
7747
7748 if (DefKind.isSpecialMember()
7749 ? CheckExplicitlyDefaultedSpecialMember(cast<CXXMethodDecl>(FD),
7750 DefKind.asSpecialMember(),
7751 FD->getDefaultLoc())
7753 FD->setInvalidDecl();
7754}
7755
7758 SourceLocation DefaultLoc) {
7759 CXXRecordDecl *RD = MD->getParent();
7760
7762 "not an explicitly-defaulted special member");
7763
7764 // Defer all checking for special members of a dependent type.
7765 if (RD->isDependentType())
7766 return false;
7767
7768 // Whether this was the first-declared instance of the constructor.
7769 // This affects whether we implicitly add an exception spec and constexpr.
7770 bool First = MD == MD->getCanonicalDecl();
7771
7772 bool HadError = false;
7773
7774 // C++11 [dcl.fct.def.default]p1:
7775 // A function that is explicitly defaulted shall
7776 // -- be a special member function [...] (checked elsewhere),
7777 // -- have the same type (except for ref-qualifiers, and except that a
7778 // copy operation can take a non-const reference) as an implicit
7779 // declaration, and
7780 // -- not have default arguments.
7781 // C++2a changes the second bullet to instead delete the function if it's
7782 // defaulted on its first declaration, unless it's "an assignment operator,
7783 // and its return type differs or its parameter type is not a reference".
7784 bool DeleteOnTypeMismatch = getLangOpts().CPlusPlus20 && First;
7785 bool ShouldDeleteForTypeMismatch = false;
7786 unsigned ExpectedParams = 1;
7789 ExpectedParams = 0;
7790 if (MD->getNumExplicitParams() != ExpectedParams) {
7791 // This checks for default arguments: a copy or move constructor with a
7792 // default argument is classified as a default constructor, and assignment
7793 // operations and destructors can't have default arguments.
7794 Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
7795 << CSM << MD->getSourceRange();
7796 HadError = true;
7797 } else if (MD->isVariadic()) {
7798 if (DeleteOnTypeMismatch)
7799 ShouldDeleteForTypeMismatch = true;
7800 else {
7801 Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
7802 << CSM << MD->getSourceRange();
7803 HadError = true;
7804 }
7805 }
7806
7808
7809 bool CanHaveConstParam = false;
7811 CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
7813 CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
7814
7815 QualType ReturnType = Context.VoidTy;
7818 // Check for return type matching.
7819 ReturnType = Type->getReturnType();
7821
7822 QualType DeclType =
7824 /*Qualifier=*/std::nullopt, RD, /*OwnsTag=*/false);
7825 DeclType = Context.getAddrSpaceQualType(
7826 DeclType, ThisType.getQualifiers().getAddressSpace());
7827 QualType ExpectedReturnType = Context.getLValueReferenceType(DeclType);
7828
7829 if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
7830 Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
7832 << ExpectedReturnType;
7833 HadError = true;
7834 }
7835
7836 // A defaulted special member cannot have cv-qualifiers.
7837 if (ThisType.isConstQualified() || ThisType.isVolatileQualified()) {
7838 if (DeleteOnTypeMismatch)
7839 ShouldDeleteForTypeMismatch = true;
7840 else {
7841 Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
7843 << getLangOpts().CPlusPlus14;
7844 HadError = true;
7845 }
7846 }
7847 // [C++23][dcl.fct.def.default]/p2.2
7848 // if F2 has an implicit object parameter of type “reference to C”,
7849 // F1 may be an explicit object member function whose explicit object
7850 // parameter is of (possibly different) type “reference to C”,
7851 // in which case the type of F1 would differ from the type of F2
7852 // in that the type of F1 has an additional parameter;
7853 QualType ExplicitObjectParameter = MD->isExplicitObjectMemberFunction()
7854 ? MD->getParamDecl(0)->getType()
7855 : QualType();
7856 if (!ExplicitObjectParameter.isNull() &&
7857 (!ExplicitObjectParameter->isReferenceType() ||
7858 !Context.hasSameType(ExplicitObjectParameter.getNonReferenceType(),
7860 if (DeleteOnTypeMismatch)
7861 ShouldDeleteForTypeMismatch = true;
7862 else {
7863 Diag(MD->getLocation(),
7864 diag::err_defaulted_special_member_explicit_object_mismatch)
7865 << (CSM == CXXSpecialMemberKind::MoveAssignment) << RD
7866 << MD->getSourceRange();
7867 HadError = true;
7868 }
7869 }
7870 }
7871
7872 // Check for parameter type matching.
7873 QualType ArgType =
7874 ExpectedParams
7875 ? Type->getParamType(MD->isExplicitObjectMemberFunction() ? 1 : 0)
7876 : QualType();
7877 bool HasConstParam = false;
7878 if (ExpectedParams && ArgType->isReferenceType()) {
7879 // Argument must be reference to possibly-const T.
7880 QualType ReferentType = ArgType->getPointeeType();
7881 HasConstParam = ReferentType.isConstQualified();
7882
7883 if (ReferentType.isVolatileQualified()) {
7884 if (DeleteOnTypeMismatch)
7885 ShouldDeleteForTypeMismatch = true;
7886 else {
7887 Diag(MD->getLocation(),
7888 diag::err_defaulted_special_member_volatile_param)
7889 << CSM;
7890 HadError = true;
7891 }
7892 }
7893
7894 if (HasConstParam && !CanHaveConstParam) {
7895 if (DeleteOnTypeMismatch)
7896 ShouldDeleteForTypeMismatch = true;
7897 else if (CSM == CXXSpecialMemberKind::CopyConstructor ||
7899 Diag(MD->getLocation(),
7900 diag::err_defaulted_special_member_copy_const_param)
7902 // FIXME: Explain why this special member can't be const.
7903 HadError = true;
7904 } else {
7905 Diag(MD->getLocation(),
7906 diag::err_defaulted_special_member_move_const_param)
7908 HadError = true;
7909 }
7910 }
7911 } else if (ExpectedParams) {
7912 // A copy assignment operator can take its argument by value, but a
7913 // defaulted one cannot.
7915 "unexpected non-ref argument");
7916 Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
7917 HadError = true;
7918 }
7919
7920 // C++11 [dcl.fct.def.default]p2:
7921 // An explicitly-defaulted function may be declared constexpr only if it
7922 // would have been implicitly declared as constexpr,
7923 // Do not apply this rule to members of class templates, since core issue 1358
7924 // makes such functions always instantiate to constexpr functions. For
7925 // functions which cannot be constexpr (for non-constructors in C++11 and for
7926 // destructors in C++14 and C++17), this is checked elsewhere.
7927 //
7928 // FIXME: This should not apply if the member is deleted.
7929 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
7930 HasConstParam);
7931
7932 // C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358):
7933 // If the instantiated template specialization of a constexpr function
7934 // template or member function of a class template would fail to satisfy
7935 // the requirements for a constexpr function or constexpr constructor, that
7936 // specialization is still a constexpr function or constexpr constructor,
7937 // even though a call to such a function cannot appear in a constant
7938 // expression.
7939 if (MD->isTemplateInstantiation() && MD->isConstexpr())
7940 Constexpr = true;
7941
7942 if ((getLangOpts().CPlusPlus20 ||
7943 (getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
7944 : isa<CXXConstructorDecl>(MD))) &&
7945 MD->isConstexpr() && !Constexpr &&
7947 if (!MD->isConsteval() && RD->getNumVBases()) {
7948 Diag(MD->getBeginLoc(),
7949 diag::err_incorrect_defaulted_constexpr_with_vb)
7950 << CSM;
7951 for (const auto &I : RD->vbases())
7952 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here);
7953 } else {
7954 Diag(MD->getBeginLoc(), diag::err_incorrect_defaulted_constexpr)
7955 << CSM << MD->isConsteval();
7956 }
7957 HadError = true;
7958 // FIXME: Explain why the special member can't be constexpr.
7959 }
7960
7961 if (First) {
7962 // C++2a [dcl.fct.def.default]p3:
7963 // If a function is explicitly defaulted on its first declaration, it is
7964 // implicitly considered to be constexpr if the implicit declaration
7965 // would be.
7970
7971 if (!Type->hasExceptionSpec()) {
7972 // C++2a [except.spec]p3:
7973 // If a declaration of a function does not have a noexcept-specifier
7974 // [and] is defaulted on its first declaration, [...] the exception
7975 // specification is as specified below
7976 FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
7978 EPI.ExceptionSpec.SourceDecl = MD;
7979 MD->setType(
7980 Context.getFunctionType(ReturnType, Type->getParamTypes(), EPI));
7981 }
7982 }
7983
7984 if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {
7985 if (First) {
7986 SetDeclDeleted(MD, MD->getLocation());
7987 if (!inTemplateInstantiation() && !HadError) {
7988 Diag(MD->getLocation(), diag::warn_defaulted_method_deleted) << CSM;
7989 if (ShouldDeleteForTypeMismatch) {
7990 Diag(MD->getLocation(), diag::note_deleted_type_mismatch) << CSM;
7991 } else if (ShouldDeleteSpecialMember(MD, CSM, nullptr,
7992 /*Diagnose*/ true) &&
7993 DefaultLoc.isValid()) {
7994 Diag(DefaultLoc, diag::note_replace_equals_default_to_delete)
7995 << FixItHint::CreateReplacement(DefaultLoc, "delete");
7996 }
7997 }
7998 if (ShouldDeleteForTypeMismatch && !HadError) {
7999 Diag(MD->getLocation(),
8000 diag::warn_cxx17_compat_defaulted_method_type_mismatch)
8001 << CSM;
8002 }
8003 } else {
8004 // C++11 [dcl.fct.def.default]p4:
8005 // [For a] user-provided explicitly-defaulted function [...] if such a
8006 // function is implicitly defined as deleted, the program is ill-formed.
8007 Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
8008 assert(!ShouldDeleteForTypeMismatch && "deleted non-first decl");
8009 ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
8010 HadError = true;
8011 }
8012 }
8013
8014 return HadError;
8015}
8016
8017namespace {
8018/// Helper class for building and checking a defaulted comparison.
8019///
8020/// Defaulted functions are built in two phases:
8021///
8022/// * First, the set of operations that the function will perform are
8023/// identified, and some of them are checked. If any of the checked
8024/// operations is invalid in certain ways, the comparison function is
8025/// defined as deleted and no body is built.
8026/// * Then, if the function is not defined as deleted, the body is built.
8027///
8028/// This is accomplished by performing two visitation steps over the eventual
8029/// body of the function.
8030template<typename Derived, typename ResultList, typename Result,
8031 typename Subobject>
8032class DefaultedComparisonVisitor {
8033public:
8034 using DefaultedComparisonKind = Sema::DefaultedComparisonKind;
8035
8036 DefaultedComparisonVisitor(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
8037 DefaultedComparisonKind DCK)
8038 : S(S), RD(RD), FD(FD), DCK(DCK) {
8039 if (auto *Info = FD->getDefalutedOrDeletedInfo()) {
8040 // FIXME: Change CreateOverloadedBinOp to take an ArrayRef instead of an
8041 // UnresolvedSet to avoid this copy.
8042 Fns.assign(Info->getUnqualifiedLookups().begin(),
8043 Info->getUnqualifiedLookups().end());
8044 }
8045 }
8046
8047 ResultList visit() {
8048 // The type of an lvalue naming a parameter of this function.
8049 QualType ParamLvalType =
8051
8052 ResultList Results;
8053
8054 switch (DCK) {
8055 case DefaultedComparisonKind::None:
8056 llvm_unreachable("not a defaulted comparison");
8057
8058 case DefaultedComparisonKind::Equal:
8059 case DefaultedComparisonKind::ThreeWay:
8060 getDerived().visitSubobjects(Results, RD, ParamLvalType.getQualifiers());
8061 return Results;
8062
8063 case DefaultedComparisonKind::NotEqual:
8064 case DefaultedComparisonKind::Relational:
8065 Results.add(getDerived().visitExpandedSubobject(
8066 ParamLvalType, getDerived().getCompleteObject()));
8067 return Results;
8068 }
8069 llvm_unreachable("");
8070 }
8071
8072protected:
8073 Derived &getDerived() { return static_cast<Derived&>(*this); }
8074
8075 /// Visit the expanded list of subobjects of the given type, as specified in
8076 /// C++2a [class.compare.default].
8077 ///
8078 /// \return \c true if the ResultList object said we're done, \c false if not.
8079 bool visitSubobjects(ResultList &Results, CXXRecordDecl *Record,
8080 Qualifiers Quals) {
8081 // C++2a [class.compare.default]p4:
8082 // The direct base class subobjects of C
8083 for (CXXBaseSpecifier &Base : Record->bases())
8084 if (Results.add(getDerived().visitSubobject(
8085 S.Context.getQualifiedType(Base.getType(), Quals),
8086 getDerived().getBase(&Base))))
8087 return true;
8088
8089 // followed by the non-static data members of C
8090 for (FieldDecl *Field : Record->fields()) {
8091 // C++23 [class.bit]p2:
8092 // Unnamed bit-fields are not members ...
8093 if (Field->isUnnamedBitField())
8094 continue;
8095 // Recursively expand anonymous structs.
8096 if (Field->isAnonymousStructOrUnion()) {
8097 if (visitSubobjects(Results, Field->getType()->getAsCXXRecordDecl(),
8098 Quals))
8099 return true;
8100 continue;
8101 }
8102
8103 // Figure out the type of an lvalue denoting this field.
8104 Qualifiers FieldQuals = Quals;
8105 if (Field->isMutable())
8106 FieldQuals.removeConst();
8107 QualType FieldType =
8108 S.Context.getQualifiedType(Field->getType(), FieldQuals);
8109
8110 if (Results.add(getDerived().visitSubobject(
8111 FieldType, getDerived().getField(Field))))
8112 return true;
8113 }
8114
8115 // form a list of subobjects.
8116 return false;
8117 }
8118
8119 Result visitSubobject(QualType Type, Subobject Subobj) {
8120 // In that list, any subobject of array type is recursively expanded
8121 const ArrayType *AT = S.Context.getAsArrayType(Type);
8122 if (auto *CAT = dyn_cast_or_null<ConstantArrayType>(AT))
8123 return getDerived().visitSubobjectArray(CAT->getElementType(),
8124 CAT->getSize(), Subobj);
8125 return getDerived().visitExpandedSubobject(Type, Subobj);
8126 }
8127
8128 Result visitSubobjectArray(QualType Type, const llvm::APInt &Size,
8129 Subobject Subobj) {
8130 return getDerived().visitSubobject(Type, Subobj);
8131 }
8132
8133protected:
8134 Sema &S;
8135 CXXRecordDecl *RD;
8136 FunctionDecl *FD;
8137 DefaultedComparisonKind DCK;
8139};
8140
8141/// Information about a defaulted comparison, as determined by
8142/// DefaultedComparisonAnalyzer.
8143struct DefaultedComparisonInfo {
8144 bool Deleted = false;
8145 bool Constexpr = true;
8146 ComparisonCategoryType Category = ComparisonCategoryType::StrongOrdering;
8147
8148 static DefaultedComparisonInfo deleted() {
8149 DefaultedComparisonInfo Deleted;
8150 Deleted.Deleted = true;
8151 return Deleted;
8152 }
8153
8154 bool add(const DefaultedComparisonInfo &R) {
8155 Deleted |= R.Deleted;
8156 Constexpr &= R.Constexpr;
8157 Category = commonComparisonType(Category, R.Category);
8158 return Deleted;
8159 }
8160};
8161
8162/// An element in the expanded list of subobjects of a defaulted comparison, as
8163/// specified in C++2a [class.compare.default]p4.
8164struct DefaultedComparisonSubobject {
8165 enum { CompleteObject, Member, Base } Kind;
8166 NamedDecl *Decl;
8168};
8169
8170/// A visitor over the notional body of a defaulted comparison that determines
8171/// whether that body would be deleted or constexpr.
8172class DefaultedComparisonAnalyzer
8173 : public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
8174 DefaultedComparisonInfo,
8175 DefaultedComparisonInfo,
8176 DefaultedComparisonSubobject> {
8177public:
8178 enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
8179
8180private:
8181 DiagnosticKind Diagnose;
8182
8183public:
8184 using Base = DefaultedComparisonVisitor;
8185 using Result = DefaultedComparisonInfo;
8186 using Subobject = DefaultedComparisonSubobject;
8187
8188 friend Base;
8189
8190 DefaultedComparisonAnalyzer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
8191 DefaultedComparisonKind DCK,
8192 DiagnosticKind Diagnose = NoDiagnostics)
8193 : Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
8194
8195 Result visit() {
8196 if ((DCK == DefaultedComparisonKind::Equal ||
8197 DCK == DefaultedComparisonKind::ThreeWay) &&
8198 RD->hasVariantMembers()) {
8199 // C++2a [class.compare.default]p2 [P2002R0]:
8200 // A defaulted comparison operator function for class C is defined as
8201 // deleted if [...] C has variant members.
8202 if (Diagnose == ExplainDeleted) {
8203 S.Diag(FD->getLocation(), diag::note_defaulted_comparison_union)
8204 << FD << RD->isUnion() << RD;
8205 }
8206 return Result::deleted();
8207 }
8208
8209 return Base::visit();
8210 }
8211
8212private:
8213 Subobject getCompleteObject() {
8214 return Subobject{Subobject::CompleteObject, RD, FD->getLocation()};
8215 }
8216
8217 Subobject getBase(CXXBaseSpecifier *Base) {
8218 return Subobject{Subobject::Base, Base->getType()->getAsCXXRecordDecl(),
8219 Base->getBaseTypeLoc()};
8220 }
8221
8222 Subobject getField(FieldDecl *Field) {
8223 return Subobject{Subobject::Member, Field, Field->getLocation()};
8224 }
8225
8226 Result visitExpandedSubobject(QualType Type, Subobject Subobj) {
8227 // C++2a [class.compare.default]p2 [P2002R0]:
8228 // A defaulted <=> or == operator function for class C is defined as
8229 // deleted if any non-static data member of C is of reference type
8230 if (Type->isReferenceType()) {
8231 if (Diagnose == ExplainDeleted) {
8232 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
8233 << FD << RD;
8234 }
8235 return Result::deleted();
8236 }
8237
8238 // [...] Let xi be an lvalue denoting the ith element [...]
8240 Expr *Args[] = {&Xi, &Xi};
8241
8242 // All operators start by trying to apply that same operator recursively.
8244 assert(OO != OO_None && "not an overloaded operator!");
8245 return visitBinaryOperator(OO, Args, Subobj);
8246 }
8247
8248 Result
8249 visitBinaryOperator(OverloadedOperatorKind OO, ArrayRef<Expr *> Args,
8250 Subobject Subobj,
8251 OverloadCandidateSet *SpaceshipCandidates = nullptr) {
8252 // Note that there is no need to consider rewritten candidates here if
8253 // we've already found there is no viable 'operator<=>' candidate (and are
8254 // considering synthesizing a '<=>' from '==' and '<').
8255 OverloadCandidateSet CandidateSet(
8258 OO, FD->getLocation(),
8259 /*AllowRewrittenCandidates=*/!SpaceshipCandidates));
8260
8261 /// C++2a [class.compare.default]p1 [P2002R0]:
8262 /// [...] the defaulted function itself is never a candidate for overload
8263 /// resolution [...]
8264 CandidateSet.exclude(FD);
8265
8266 if (Args[0]->getType()->isOverloadableType())
8267 S.LookupOverloadedBinOp(CandidateSet, OO, Fns, Args);
8268 else
8269 // FIXME: We determine whether this is a valid expression by checking to
8270 // see if there's a viable builtin operator candidate for it. That isn't
8271 // really what the rules ask us to do, but should give the right results.
8272 S.AddBuiltinOperatorCandidates(OO, FD->getLocation(), Args, CandidateSet);
8273
8274 Result R;
8275
8277 switch (CandidateSet.BestViableFunction(S, FD->getLocation(), Best)) {
8278 case OR_Success: {
8279 // C++2a [class.compare.secondary]p2 [P2002R0]:
8280 // The operator function [...] is defined as deleted if [...] the
8281 // candidate selected by overload resolution is not a rewritten
8282 // candidate.
8283 if ((DCK == DefaultedComparisonKind::NotEqual ||
8284 DCK == DefaultedComparisonKind::Relational) &&
8285 !Best->RewriteKind) {
8286 if (Diagnose == ExplainDeleted) {
8287 if (Best->Function) {
8288 S.Diag(Best->Function->getLocation(),
8289 diag::note_defaulted_comparison_not_rewritten_callee)
8290 << FD;
8291 } else {
8292 assert(Best->Conversions.size() == 2 &&
8293 Best->Conversions[0].isUserDefined() &&
8294 "non-user-defined conversion from class to built-in "
8295 "comparison");
8296 S.Diag(Best->Conversions[0]
8297 .UserDefined.FoundConversionFunction.getDecl()
8298 ->getLocation(),
8299 diag::note_defaulted_comparison_not_rewritten_conversion)
8300 << FD;
8301 }
8302 }
8303 return Result::deleted();
8304 }
8305
8306 // Throughout C++2a [class.compare]: if overload resolution does not
8307 // result in a usable function, the candidate function is defined as
8308 // deleted. This requires that we selected an accessible function.
8309 //
8310 // Note that this only considers the access of the function when named
8311 // within the type of the subobject, and not the access path for any
8312 // derived-to-base conversion.
8313 CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
8314 if (ArgClass && Best->FoundDecl.getDecl() &&
8315 Best->FoundDecl.getDecl()->isCXXClassMember()) {
8316 QualType ObjectType = Subobj.Kind == Subobject::Member
8317 ? Args[0]->getType()
8320 ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
8321 Diagnose == ExplainDeleted
8322 ? S.PDiag(diag::note_defaulted_comparison_inaccessible)
8323 << FD << Subobj.Kind << Subobj.Decl
8324 : S.PDiag()))
8325 return Result::deleted();
8326 }
8327
8328 bool NeedsDeducing =
8329 OO == OO_Spaceship && FD->getReturnType()->isUndeducedAutoType();
8330
8331 if (FunctionDecl *BestFD = Best->Function) {
8332 // C++2a [class.compare.default]p3 [P2002R0]:
8333 // A defaulted comparison function is constexpr-compatible if
8334 // [...] no overlod resolution performed [...] results in a
8335 // non-constexpr function.
8336 assert(!BestFD->isDeleted() && "wrong overload resolution result");
8337 // If it's not constexpr, explain why not.
8338 if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
8339 if (Subobj.Kind != Subobject::CompleteObject)
8340 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
8341 << Subobj.Kind << Subobj.Decl;
8342 S.Diag(BestFD->getLocation(),
8343 diag::note_defaulted_comparison_not_constexpr_here);
8344 // Bail out after explaining; we don't want any more notes.
8345 return Result::deleted();
8346 }
8347 R.Constexpr &= BestFD->isConstexpr();
8348
8349 if (NeedsDeducing) {
8350 // If any callee has an undeduced return type, deduce it now.
8351 // FIXME: It's not clear how a failure here should be handled. For
8352 // now, we produce an eager diagnostic, because that is forward
8353 // compatible with most (all?) other reasonable options.
8354 if (BestFD->getReturnType()->isUndeducedType() &&
8355 S.DeduceReturnType(BestFD, FD->getLocation(),
8356 /*Diagnose=*/false)) {
8357 // Don't produce a duplicate error when asked to explain why the
8358 // comparison is deleted: we diagnosed that when initially checking
8359 // the defaulted operator.
8360 if (Diagnose == NoDiagnostics) {
8361 S.Diag(
8362 FD->getLocation(),
8363 diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
8364 << Subobj.Kind << Subobj.Decl;
8365 S.Diag(
8366 Subobj.Loc,
8367 diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
8368 << Subobj.Kind << Subobj.Decl;
8369 S.Diag(BestFD->getLocation(),
8370 diag::note_defaulted_comparison_cannot_deduce_callee)
8371 << Subobj.Kind << Subobj.Decl;
8372 }
8373 return Result::deleted();
8374 }
8376 BestFD->getCallResultType());
8377 if (!Info) {
8378 if (Diagnose == ExplainDeleted) {
8379 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
8380 << Subobj.Kind << Subobj.Decl
8381 << BestFD->getCallResultType().withoutLocalFastQualifiers();
8382 S.Diag(BestFD->getLocation(),
8383 diag::note_defaulted_comparison_cannot_deduce_callee)
8384 << Subobj.Kind << Subobj.Decl;
8385 }
8386 return Result::deleted();
8387 }
8388 R.Category = Info->Kind;
8389 }
8390 } else {
8391 QualType T = Best->BuiltinParamTypes[0];
8392 assert(T == Best->BuiltinParamTypes[1] &&
8393 "builtin comparison for different types?");
8394 assert(Best->BuiltinParamTypes[2].isNull() &&
8395 "invalid builtin comparison");
8396
8397 // FIXME: If the type we deduced is a vector type, we mark the
8398 // comparison as deleted because we don't yet support this.
8399 if (isa<VectorType>(T)) {
8400 if (Diagnose == ExplainDeleted) {
8401 S.Diag(FD->getLocation(),
8402 diag::note_defaulted_comparison_vector_types)
8403 << FD;
8404 S.Diag(Subobj.Decl->getLocation(), diag::note_declared_at);
8405 }
8406 return Result::deleted();
8407 }
8408
8409 if (NeedsDeducing) {
8410 std::optional<ComparisonCategoryType> Cat =
8412 assert(Cat && "no category for builtin comparison?");
8413 R.Category = *Cat;
8414 }
8415 }
8416
8417 // Note that we might be rewriting to a different operator. That call is
8418 // not considered until we come to actually build the comparison function.
8419 break;
8420 }
8421
8422 case OR_Ambiguous:
8423 if (Diagnose == ExplainDeleted) {
8424 unsigned Kind = 0;
8425 if (FD->getOverloadedOperator() == OO_Spaceship && OO != OO_Spaceship)
8426 Kind = OO == OO_EqualEqual ? 1 : 2;
8427 CandidateSet.NoteCandidates(
8429 Subobj.Loc, S.PDiag(diag::note_defaulted_comparison_ambiguous)
8430 << FD << Kind << Subobj.Kind << Subobj.Decl),
8431 S, OCD_AmbiguousCandidates, Args);
8432 }
8433 R = Result::deleted();
8434 break;
8435
8436 case OR_Deleted:
8437 if (Diagnose == ExplainDeleted) {
8438 if ((DCK == DefaultedComparisonKind::NotEqual ||
8439 DCK == DefaultedComparisonKind::Relational) &&
8440 !Best->RewriteKind) {
8441 S.Diag(Best->Function->getLocation(),
8442 diag::note_defaulted_comparison_not_rewritten_callee)
8443 << FD;
8444 } else {
8445 S.Diag(Subobj.Loc,
8446 diag::note_defaulted_comparison_calls_deleted)
8447 << FD << Subobj.Kind << Subobj.Decl;
8448 S.NoteDeletedFunction(Best->Function);
8449 }
8450 }
8451 R = Result::deleted();
8452 break;
8453
8455 // If there's no usable candidate, we're done unless we can rewrite a
8456 // '<=>' in terms of '==' and '<'.
8457 if (OO == OO_Spaceship &&
8459 // For any kind of comparison category return type, we need a usable
8460 // '==' and a usable '<'.
8461 if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
8462 &CandidateSet)))
8463 R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
8464 break;
8465 }
8466
8467 if (Diagnose == ExplainDeleted) {
8468 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
8469 << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
8470 << Subobj.Kind << Subobj.Decl;
8471
8472 // For a three-way comparison, list both the candidates for the
8473 // original operator and the candidates for the synthesized operator.
8474 if (SpaceshipCandidates) {
8475 SpaceshipCandidates->NoteCandidates(
8476 S, Args,
8477 SpaceshipCandidates->CompleteCandidates(S, OCD_AllCandidates,
8478 Args, FD->getLocation()));
8479 S.Diag(Subobj.Loc,
8480 diag::note_defaulted_comparison_no_viable_function_synthesized)
8481 << (OO == OO_EqualEqual ? 0 : 1);
8482 }
8483
8484 CandidateSet.NoteCandidates(
8485 S, Args,
8486 CandidateSet.CompleteCandidates(S, OCD_AllCandidates, Args,
8487 FD->getLocation()));
8488 }
8489 R = Result::deleted();
8490 break;
8491 }
8492
8493 return R;
8494 }
8495};
8496
8497/// A list of statements.
8498struct StmtListResult {
8499 bool IsInvalid = false;
8501
8502 bool add(const StmtResult &S) {
8503 IsInvalid |= S.isInvalid();
8504 if (IsInvalid)
8505 return true;
8506 Stmts.push_back(S.get());
8507 return false;
8508 }
8509};
8510
8511/// A visitor over the notional body of a defaulted comparison that synthesizes
8512/// the actual body.
8513class DefaultedComparisonSynthesizer
8514 : public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
8515 StmtListResult, StmtResult,
8516 std::pair<ExprResult, ExprResult>> {
8518 unsigned ArrayDepth = 0;
8519
8520public:
8521 using Base = DefaultedComparisonVisitor;
8522 using ExprPair = std::pair<ExprResult, ExprResult>;
8523
8524 friend Base;
8525
8526 DefaultedComparisonSynthesizer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
8527 DefaultedComparisonKind DCK,
8528 SourceLocation BodyLoc)
8529 : Base(S, RD, FD, DCK), Loc(BodyLoc) {}
8530
8531 /// Build a suitable function body for this defaulted comparison operator.
8532 StmtResult build() {
8533 Sema::CompoundScopeRAII CompoundScope(S);
8534
8535 StmtListResult Stmts = visit();
8536 if (Stmts.IsInvalid)
8537 return StmtError();
8538
8539 ExprResult RetVal;
8540 switch (DCK) {
8541 case DefaultedComparisonKind::None:
8542 llvm_unreachable("not a defaulted comparison");
8543
8544 case DefaultedComparisonKind::Equal: {
8545 // C++2a [class.eq]p3:
8546 // [...] compar[e] the corresponding elements [...] until the first
8547 // index i where xi == yi yields [...] false. If no such index exists,
8548 // V is true. Otherwise, V is false.
8549 //
8550 // Join the comparisons with '&&'s and return the result. Use a right
8551 // fold (traversing the conditions right-to-left), because that
8552 // short-circuits more naturally.
8553 auto OldStmts = std::move(Stmts.Stmts);
8554 Stmts.Stmts.clear();
8555 ExprResult CmpSoFar;
8556 // Finish a particular comparison chain.
8557 auto FinishCmp = [&] {
8558 if (Expr *Prior = CmpSoFar.get()) {
8559 // Convert the last expression to 'return ...;'
8560 if (RetVal.isUnset() && Stmts.Stmts.empty())
8561 RetVal = CmpSoFar;
8562 // Convert any prior comparison to 'if (!(...)) return false;'
8563 else if (Stmts.add(buildIfNotCondReturnFalse(Prior)))
8564 return true;
8565 CmpSoFar = ExprResult();
8566 }
8567 return false;
8568 };
8569 for (Stmt *EAsStmt : llvm::reverse(OldStmts)) {
8570 Expr *E = dyn_cast<Expr>(EAsStmt);
8571 if (!E) {
8572 // Found an array comparison.
8573 if (FinishCmp() || Stmts.add(EAsStmt))
8574 return StmtError();
8575 continue;
8576 }
8577
8578 if (CmpSoFar.isUnset()) {
8579 CmpSoFar = E;
8580 continue;
8581 }
8582 CmpSoFar = S.CreateBuiltinBinOp(Loc, BO_LAnd, E, CmpSoFar.get());
8583 if (CmpSoFar.isInvalid())
8584 return StmtError();
8585 }
8586 if (FinishCmp())
8587 return StmtError();
8588 std::reverse(Stmts.Stmts.begin(), Stmts.Stmts.end());
8589 // If no such index exists, V is true.
8590 if (RetVal.isUnset())
8591 RetVal = S.ActOnCXXBoolLiteral(Loc, tok::kw_true);
8592 break;
8593 }
8594
8595 case DefaultedComparisonKind::ThreeWay: {
8596 // Per C++2a [class.spaceship]p3, as a fallback add:
8597 // return static_cast<R>(std::strong_ordering::equal);
8599 ComparisonCategoryType::StrongOrdering, Loc,
8600 Sema::ComparisonCategoryUsage::DefaultedOperator);
8601 if (StrongOrdering.isNull())
8602 return StmtError();
8604 .getValueInfo(ComparisonCategoryResult::Equal)
8605 ->VD;
8606 RetVal = getDecl(EqualVD);
8607 if (RetVal.isInvalid())
8608 return StmtError();
8609 RetVal = buildStaticCastToR(RetVal.get());
8610 break;
8611 }
8612
8613 case DefaultedComparisonKind::NotEqual:
8614 case DefaultedComparisonKind::Relational:
8615 RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
8616 break;
8617 }
8618
8619 // Build the final return statement.
8620 if (RetVal.isInvalid())
8621 return StmtError();
8623 if (ReturnStmt.isInvalid())
8624 return StmtError();
8625 Stmts.Stmts.push_back(ReturnStmt.get());
8626
8627 return S.ActOnCompoundStmt(Loc, Loc, Stmts.Stmts, /*IsStmtExpr=*/false);
8628 }
8629
8630private:
8631 ExprResult getDecl(ValueDecl *VD) {
8632 return S.BuildDeclarationNameExpr(
8634 }
8635
8636 ExprResult getParam(unsigned I) {
8637 ParmVarDecl *PD = FD->getParamDecl(I);
8638 return getDecl(PD);
8639 }
8640
8641 ExprPair getCompleteObject() {
8642 unsigned Param = 0;
8643 ExprResult LHS;
8644 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD);
8645 MD && MD->isImplicitObjectMemberFunction()) {
8646 // LHS is '*this'.
8647 LHS = S.ActOnCXXThis(Loc);
8648 if (!LHS.isInvalid())
8649 LHS = S.CreateBuiltinUnaryOp(Loc, UO_Deref, LHS.get());
8650 } else {
8651 LHS = getParam(Param++);
8652 }
8653 ExprResult RHS = getParam(Param++);
8654 assert(Param == FD->getNumParams());
8655 return {LHS, RHS};
8656 }
8657
8658 ExprPair getBase(CXXBaseSpecifier *Base) {
8659 ExprPair Obj = getCompleteObject();
8660 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8661 return {ExprError(), ExprError()};
8662 CXXCastPath Path = {Base};
8663 const auto CastToBase = [&](Expr *E) {
8665 Base->getType(), E->getType().getQualifiers());
8666 return S.ImpCastExprToType(E, ToType, CK_DerivedToBase, VK_LValue, &Path);
8667 };
8668 return {CastToBase(Obj.first.get()), CastToBase(Obj.second.get())};
8669 }
8670
8671 ExprPair getField(FieldDecl *Field) {
8672 ExprPair Obj = getCompleteObject();
8673 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8674 return {ExprError(), ExprError()};
8675
8676 DeclAccessPair Found = DeclAccessPair::make(Field, Field->getAccess());
8677 DeclarationNameInfo NameInfo(Field->getDeclName(), Loc);
8678 return {S.BuildFieldReferenceExpr(Obj.first.get(), /*IsArrow=*/false, Loc,
8679 CXXScopeSpec(), Field, Found, NameInfo),
8680 S.BuildFieldReferenceExpr(Obj.second.get(), /*IsArrow=*/false, Loc,
8681 CXXScopeSpec(), Field, Found, NameInfo)};
8682 }
8683
8684 // FIXME: When expanding a subobject, register a note in the code synthesis
8685 // stack to say which subobject we're comparing.
8686
8687 StmtResult buildIfNotCondReturnFalse(ExprResult Cond) {
8688 if (Cond.isInvalid())
8689 return StmtError();
8690
8691 ExprResult NotCond = S.CreateBuiltinUnaryOp(Loc, UO_LNot, Cond.get());
8692 if (NotCond.isInvalid())
8693 return StmtError();
8694
8695 ExprResult False = S.ActOnCXXBoolLiteral(Loc, tok::kw_false);
8696 assert(!False.isInvalid() && "should never fail");
8697 StmtResult ReturnFalse = S.BuildReturnStmt(Loc, False.get());
8698 if (ReturnFalse.isInvalid())
8699 return StmtError();
8700
8701 return S.ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc, nullptr,
8702 S.ActOnCondition(nullptr, Loc, NotCond.get(),
8703 Sema::ConditionKind::Boolean),
8704 Loc, ReturnFalse.get(), SourceLocation(), nullptr);
8705 }
8706
8707 StmtResult visitSubobjectArray(QualType Type, llvm::APInt Size,
8708 ExprPair Subobj) {
8709 QualType SizeType = S.Context.getSizeType();
8710 Size = Size.zextOrTrunc(S.Context.getTypeSize(SizeType));
8711
8712 // Build 'size_t i$n = 0'.
8713 IdentifierInfo *IterationVarName = nullptr;
8714 {
8715 SmallString<8> Str;
8716 llvm::raw_svector_ostream OS(Str);
8717 OS << "i" << ArrayDepth;
8718 IterationVarName = &S.Context.Idents.get(OS.str());
8719 }
8720 VarDecl *IterationVar = VarDecl::Create(
8721 S.Context, S.CurContext, Loc, Loc, IterationVarName, SizeType,
8723 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
8724 IterationVar->setInit(
8725 IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
8726 Stmt *Init = new (S.Context) DeclStmt(DeclGroupRef(IterationVar), Loc, Loc);
8727
8728 auto IterRef = [&] {
8730 CXXScopeSpec(), DeclarationNameInfo(IterationVarName, Loc),
8731 IterationVar);
8732 assert(!Ref.isInvalid() && "can't reference our own variable?");
8733 return Ref.get();
8734 };
8735
8736 // Build 'i$n != Size'.
8738 Loc, BO_NE, IterRef(),
8739 IntegerLiteral::Create(S.Context, Size, SizeType, Loc));
8740 assert(!Cond.isInvalid() && "should never fail");
8741
8742 // Build '++i$n'.
8743 ExprResult Inc = S.CreateBuiltinUnaryOp(Loc, UO_PreInc, IterRef());
8744 assert(!Inc.isInvalid() && "should never fail");
8745
8746 // Build 'a[i$n]' and 'b[i$n]'.
8747 auto Index = [&](ExprResult E) {
8748 if (E.isInvalid())
8749 return ExprError();
8750 return S.CreateBuiltinArraySubscriptExpr(E.get(), Loc, IterRef(), Loc);
8751 };
8752 Subobj.first = Index(Subobj.first);
8753 Subobj.second = Index(Subobj.second);
8754
8755 // Compare the array elements.
8756 ++ArrayDepth;
8757 StmtResult Substmt = visitSubobject(Type, Subobj);
8758 --ArrayDepth;
8759
8760 if (Substmt.isInvalid())
8761 return StmtError();
8762
8763 // For the inner level of an 'operator==', build 'if (!cmp) return false;'.
8764 // For outer levels or for an 'operator<=>' we already have a suitable
8765 // statement that returns as necessary.
8766 if (Expr *ElemCmp = dyn_cast<Expr>(Substmt.get())) {
8767 assert(DCK == DefaultedComparisonKind::Equal &&
8768 "should have non-expression statement");
8769 Substmt = buildIfNotCondReturnFalse(ElemCmp);
8770 if (Substmt.isInvalid())
8771 return StmtError();
8772 }
8773
8774 // Build 'for (...) ...'
8775 return S.ActOnForStmt(Loc, Loc, Init,
8776 S.ActOnCondition(nullptr, Loc, Cond.get(),
8777 Sema::ConditionKind::Boolean),
8779 Substmt.get());
8780 }
8781
8782 StmtResult visitExpandedSubobject(QualType Type, ExprPair Obj) {
8783 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8784 return StmtError();
8785
8788 ExprResult Op;
8789 if (Type->isOverloadableType())
8790 Op = S.CreateOverloadedBinOp(Loc, Opc, Fns, Obj.first.get(),
8791 Obj.second.get(), /*PerformADL=*/true,
8792 /*AllowRewrittenCandidates=*/true, FD);
8793 else
8794 Op = S.CreateBuiltinBinOp(Loc, Opc, Obj.first.get(), Obj.second.get());
8795 if (Op.isInvalid())
8796 return StmtError();
8797
8798 switch (DCK) {
8799 case DefaultedComparisonKind::None:
8800 llvm_unreachable("not a defaulted comparison");
8801
8802 case DefaultedComparisonKind::Equal:
8803 // Per C++2a [class.eq]p2, each comparison is individually contextually
8804 // converted to bool.
8806 if (Op.isInvalid())
8807 return StmtError();
8808 return Op.get();
8809
8810 case DefaultedComparisonKind::ThreeWay: {
8811 // Per C++2a [class.spaceship]p3, form:
8812 // if (R cmp = static_cast<R>(op); cmp != 0)
8813 // return cmp;
8814 QualType R = FD->getReturnType();
8815 Op = buildStaticCastToR(Op.get());
8816 if (Op.isInvalid())
8817 return StmtError();
8818
8819 // R cmp = ...;
8820 IdentifierInfo *Name = &S.Context.Idents.get("cmp");
8821 VarDecl *VD =
8822 VarDecl::Create(S.Context, S.CurContext, Loc, Loc, Name, R,
8824 S.AddInitializerToDecl(VD, Op.get(), /*DirectInit=*/false);
8825 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(VD), Loc, Loc);
8826
8827 // cmp != 0
8828 ExprResult VDRef = getDecl(VD);
8829 if (VDRef.isInvalid())
8830 return StmtError();
8831 llvm::APInt ZeroVal(S.Context.getIntWidth(S.Context.IntTy), 0);
8832 Expr *Zero =
8835 if (VDRef.get()->getType()->isOverloadableType())
8836 Comp = S.CreateOverloadedBinOp(Loc, BO_NE, Fns, VDRef.get(), Zero, true,
8837 true, FD);
8838 else
8839 Comp = S.CreateBuiltinBinOp(Loc, BO_NE, VDRef.get(), Zero);
8840 if (Comp.isInvalid())
8841 return StmtError();
8843 nullptr, Loc, Comp.get(), Sema::ConditionKind::Boolean);
8844 if (Cond.isInvalid())
8845 return StmtError();
8846
8847 // return cmp;
8848 VDRef = getDecl(VD);
8849 if (VDRef.isInvalid())
8850 return StmtError();
8852 if (ReturnStmt.isInvalid())
8853 return StmtError();
8854
8855 // if (...)
8856 return S.ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc, InitStmt, Cond,
8857 Loc, ReturnStmt.get(),
8858 /*ElseLoc=*/SourceLocation(), /*Else=*/nullptr);
8859 }
8860
8861 case DefaultedComparisonKind::NotEqual:
8862 case DefaultedComparisonKind::Relational:
8863 // C++2a [class.compare.secondary]p2:
8864 // Otherwise, the operator function yields x @ y.
8865 return Op.get();
8866 }
8867 llvm_unreachable("");
8868 }
8869
8870 /// Build "static_cast<R>(E)".
8871 ExprResult buildStaticCastToR(Expr *E) {
8872 QualType R = FD->getReturnType();
8873 assert(!R->isUndeducedType() && "type should have been deduced already");
8874
8875 // Don't bother forming a no-op cast in the common case.
8876 if (E->isPRValue() && S.Context.hasSameType(E->getType(), R))
8877 return E;
8878 return S.BuildCXXNamedCast(Loc, tok::kw_static_cast,
8881 }
8882};
8883}
8884
8885/// Perform the unqualified lookups that might be needed to form a defaulted
8886/// comparison function for the given operator.
8888 UnresolvedSetImpl &Operators,
8890 auto Lookup = [&](OverloadedOperatorKind OO) {
8891 Self.LookupOverloadedOperatorName(OO, S, Operators);
8892 };
8893
8894 // Every defaulted operator looks up itself.
8895 Lookup(Op);
8896 // ... and the rewritten form of itself, if any.
8898 Lookup(ExtraOp);
8899
8900 // For 'operator<=>', we also form a 'cmp != 0' expression, and might
8901 // synthesize a three-way comparison from '<' and '=='. In a dependent
8902 // context, we also need to look up '==' in case we implicitly declare a
8903 // defaulted 'operator=='.
8904 if (Op == OO_Spaceship) {
8905 Lookup(OO_ExclaimEqual);
8906 Lookup(OO_Less);
8907 Lookup(OO_EqualEqual);
8908 }
8909}
8910
8913 assert(DCK != DefaultedComparisonKind::None && "not a defaulted comparison");
8914
8915 // Perform any unqualified lookups we're going to need to default this
8916 // function.
8917 if (S) {
8918 UnresolvedSet<32> Operators;
8919 lookupOperatorsForDefaultedComparison(*this, S, Operators,
8920 FD->getOverloadedOperator());
8923 Context, Operators.pairs()));
8924 }
8925
8926 // C++2a [class.compare.default]p1:
8927 // A defaulted comparison operator function for some class C shall be a
8928 // non-template function declared in the member-specification of C that is
8929 // -- a non-static const non-volatile member of C having one parameter of
8930 // type const C& and either no ref-qualifier or the ref-qualifier &, or
8931 // -- a friend of C having two parameters of type const C& or two
8932 // parameters of type C.
8933
8934 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalDeclContext());
8935 bool IsMethod = isa<CXXMethodDecl>(FD);
8936 if (IsMethod) {
8937 auto *MD = cast<CXXMethodDecl>(FD);
8938 assert(!MD->isStatic() && "comparison function cannot be a static member");
8939
8940 if (MD->getRefQualifier() == RQ_RValue) {
8941 Diag(MD->getLocation(), diag::err_ref_qualifier_comparison_operator);
8942
8943 // Remove the ref qualifier to recover.
8944 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8945 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8946 EPI.RefQualifier = RQ_None;
8947 MD->setType(Context.getFunctionType(FPT->getReturnType(),
8948 FPT->getParamTypes(), EPI));
8949 }
8950
8951 // If we're out-of-class, this is the class we're comparing.
8952 if (!RD)
8953 RD = MD->getParent();
8955 if (!T.getNonReferenceType().isConstQualified() &&
8957 SourceLocation Loc, InsertLoc;
8959 Loc = MD->getParamDecl(0)->getBeginLoc();
8960 InsertLoc = getLocForEndOfToken(
8962 } else {
8963 Loc = MD->getLocation();
8965 InsertLoc = Loc.getRParenLoc();
8966 }
8967 // Don't diagnose an implicit 'operator=='; we will have diagnosed the
8968 // corresponding defaulted 'operator<=>' already.
8969 if (!MD->isImplicit()) {
8970 Diag(Loc, diag::err_defaulted_comparison_non_const)
8971 << (int)DCK << FixItHint::CreateInsertion(InsertLoc, " const");
8972 }
8973
8974 // Add the 'const' to the type to recover.
8976 assert(T->isLValueReferenceType());
8978 T.getNonReferenceType().withConst()));
8979 } else {
8980 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8981 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8982 EPI.TypeQuals.addConst();
8983 MD->setType(Context.getFunctionType(FPT->getReturnType(),
8984 FPT->getParamTypes(), EPI));
8985 }
8986 }
8987
8988 if (MD->isVolatile()) {
8989 Diag(MD->getLocation(), diag::err_volatile_comparison_operator);
8990
8991 // Remove the 'volatile' from the type to recover.
8992 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8993 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8995 MD->setType(Context.getFunctionType(FPT->getReturnType(),
8996 FPT->getParamTypes(), EPI));
8997 }
8998 }
8999
9000 if ((FD->getNumParams() -
9001 (unsigned)FD->hasCXXExplicitFunctionObjectParameter()) !=
9002 (IsMethod ? 1 : 2)) {
9003 // Let's not worry about using a variadic template pack here -- who would do
9004 // such a thing?
9005 Diag(FD->getLocation(), diag::err_defaulted_comparison_num_args)
9006 << int(IsMethod) << int(DCK);
9007 return true;
9008 }
9009
9010 const ParmVarDecl *KnownParm = nullptr;
9011 for (const ParmVarDecl *Param : FD->parameters()) {
9012 QualType ParmTy = Param->getType();
9013 if (!KnownParm) {
9014 auto CTy = ParmTy;
9015 // Is it `T const &`?
9016 bool Ok = !IsMethod || FD->hasCXXExplicitFunctionObjectParameter();
9017 QualType ExpectedTy;
9018 if (RD)
9019 ExpectedTy = Context.getCanonicalTagType(RD);
9020 if (auto *Ref = CTy->getAs<LValueReferenceType>()) {
9021 CTy = Ref->getPointeeType();
9022 if (RD)
9023 ExpectedTy.addConst();
9024 Ok = true;
9025 }
9026
9027 // Is T a class?
9028 if (RD) {
9029 Ok &= RD->isDependentType() || Context.hasSameType(CTy, ExpectedTy);
9030 } else {
9031 RD = CTy->getAsCXXRecordDecl();
9032 Ok &= RD != nullptr;
9033 }
9034
9035 if (Ok) {
9036 KnownParm = Param;
9037 } else {
9038 // Don't diagnose an implicit 'operator=='; we will have diagnosed the
9039 // corresponding defaulted 'operator<=>' already.
9040 if (!FD->isImplicit()) {
9041 if (RD) {
9043 QualType RefTy =
9045 Diag(FD->getLocation(), diag::err_defaulted_comparison_param)
9046 << int(DCK) << ParmTy << RefTy << int(!IsMethod) << PlainTy
9047 << Param->getSourceRange();
9048 } else {
9049 assert(!IsMethod && "should know expected type for method");
9050 Diag(FD->getLocation(),
9051 diag::err_defaulted_comparison_param_unknown)
9052 << int(DCK) << ParmTy << Param->getSourceRange();
9053 }
9054 }
9055 return true;
9056 }
9057 } else if (!Context.hasSameType(KnownParm->getType(), ParmTy)) {
9058 Diag(FD->getLocation(), diag::err_defaulted_comparison_param_mismatch)
9059 << int(DCK) << KnownParm->getType() << KnownParm->getSourceRange()
9060 << ParmTy << Param->getSourceRange();
9061 return true;
9062 }
9063 }
9064
9065 assert(RD && "must have determined class");
9066 if (IsMethod) {
9067 } else if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
9068 // In-class, must be a friend decl.
9069 assert(FD->getFriendObjectKind() && "expected a friend declaration");
9070 } else {
9071 // Out of class, require the defaulted comparison to be a friend (of a
9072 // complete type, per CWG2547).
9074 diag::err_defaulted_comparison_not_friend, int(DCK),
9075 int(1)))
9076 return true;
9077
9078 if (llvm::none_of(RD->friends(), [&](const FriendDecl *F) {
9079 return declaresSameEntity(F->getFriendDecl(), FD);
9080 })) {
9081 Diag(FD->getLocation(), diag::err_defaulted_comparison_not_friend)
9082 << int(DCK) << int(0) << RD;
9083 Diag(RD->getCanonicalDecl()->getLocation(), diag::note_declared_at);
9084 return true;
9085 }
9086 }
9087
9088 // C++2a [class.eq]p1, [class.rel]p1:
9089 // A [defaulted comparison other than <=>] shall have a declared return
9090 // type bool.
9094 Diag(FD->getLocation(), diag::err_defaulted_comparison_return_type_not_bool)
9095 << (int)DCK << FD->getDeclaredReturnType() << Context.BoolTy
9096 << FD->getReturnTypeSourceRange();
9097 return true;
9098 }
9099 // C++2a [class.spaceship]p2 [P2002R0]:
9100 // Let R be the declared return type [...]. If R is auto, [...]. Otherwise,
9101 // R shall not contain a placeholder type.
9102 if (QualType RT = FD->getDeclaredReturnType();
9104 RT->getContainedDeducedType() &&
9106 RT->getContainedAutoType()->isConstrained())) {
9107 Diag(FD->getLocation(),
9108 diag::err_defaulted_comparison_deduced_return_type_not_auto)
9109 << (int)DCK << FD->getDeclaredReturnType() << Context.AutoDeductTy
9110 << FD->getReturnTypeSourceRange();
9111 return true;
9112 }
9113
9114 // For a defaulted function in a dependent class, defer all remaining checks
9115 // until instantiation.
9116 if (RD->isDependentType())
9117 return false;
9118
9119 // Determine whether the function should be defined as deleted.
9120 DefaultedComparisonInfo Info =
9121 DefaultedComparisonAnalyzer(*this, RD, FD, DCK).visit();
9122
9123 bool First = FD == FD->getCanonicalDecl();
9124
9125 if (!First) {
9126 if (Info.Deleted) {
9127 // C++11 [dcl.fct.def.default]p4:
9128 // [For a] user-provided explicitly-defaulted function [...] if such a
9129 // function is implicitly defined as deleted, the program is ill-formed.
9130 //
9131 // This is really just a consequence of the general rule that you can
9132 // only delete a function on its first declaration.
9133 Diag(FD->getLocation(), diag::err_non_first_default_compare_deletes)
9134 << FD->isImplicit() << (int)DCK;
9135 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
9136 DefaultedComparisonAnalyzer::ExplainDeleted)
9137 .visit();
9138 return true;
9139 }
9140 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
9141 // C++20 [class.compare.default]p1:
9142 // [...] A definition of a comparison operator as defaulted that appears
9143 // in a class shall be the first declaration of that function.
9144 Diag(FD->getLocation(), diag::err_non_first_default_compare_in_class)
9145 << (int)DCK;
9147 diag::note_previous_declaration);
9148 return true;
9149 }
9150 }
9151
9152 // If we want to delete the function, then do so; there's nothing else to
9153 // check in that case.
9154 if (Info.Deleted) {
9155 SetDeclDeleted(FD, FD->getLocation());
9156 if (!inTemplateInstantiation() && !FD->isImplicit()) {
9157 Diag(FD->getLocation(), diag::warn_defaulted_comparison_deleted)
9158 << (int)DCK;
9159 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
9160 DefaultedComparisonAnalyzer::ExplainDeleted)
9161 .visit();
9162 if (FD->getDefaultLoc().isValid())
9163 Diag(FD->getDefaultLoc(), diag::note_replace_equals_default_to_delete)
9164 << FixItHint::CreateReplacement(FD->getDefaultLoc(), "delete");
9165 }
9166 return false;
9167 }
9168
9169 // C++2a [class.spaceship]p2:
9170 // The return type is deduced as the common comparison type of R0, R1, ...
9174 if (RetLoc.isInvalid())
9175 RetLoc = FD->getBeginLoc();
9176 // FIXME: Should we really care whether we have the complete type and the
9177 // 'enumerator' constants here? A forward declaration seems sufficient.
9179 Info.Category, RetLoc, ComparisonCategoryUsage::DefaultedOperator);
9180 if (Cat.isNull())
9181 return true;
9183 FD, SubstAutoType(FD->getDeclaredReturnType(), Cat));
9184 }
9185
9186 // C++2a [dcl.fct.def.default]p3 [P2002R0]:
9187 // An explicitly-defaulted function that is not defined as deleted may be
9188 // declared constexpr or consteval only if it is constexpr-compatible.
9189 // C++2a [class.compare.default]p3 [P2002R0]:
9190 // A defaulted comparison function is constexpr-compatible if it satisfies
9191 // the requirements for a constexpr function [...]
9192 // The only relevant requirements are that the parameter and return types are
9193 // literal types. The remaining conditions are checked by the analyzer.
9194 //
9195 // We support P2448R2 in language modes earlier than C++23 as an extension.
9196 // The concept of constexpr-compatible was removed.
9197 // C++23 [dcl.fct.def.default]p3 [P2448R2]
9198 // A function explicitly defaulted on its first declaration is implicitly
9199 // inline, and is implicitly constexpr if it is constexpr-suitable.
9200 // C++23 [dcl.constexpr]p3
9201 // A function is constexpr-suitable if
9202 // - it is not a coroutine, and
9203 // - if the function is a constructor or destructor, its class does not
9204 // have any virtual base classes.
9205 if (FD->isConstexpr()) {
9206 if (!getLangOpts().CPlusPlus23 &&
9209 !Info.Constexpr) {
9210 Diag(FD->getBeginLoc(), diag::err_defaulted_comparison_constexpr_mismatch)
9211 << FD->isImplicit() << (int)DCK << FD->isConsteval();
9212 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
9213 DefaultedComparisonAnalyzer::ExplainConstexpr)
9214 .visit();
9215 }
9216 }
9217
9218 // C++2a [dcl.fct.def.default]p3 [P2002R0]:
9219 // If a constexpr-compatible function is explicitly defaulted on its first
9220 // declaration, it is implicitly considered to be constexpr.
9221 // FIXME: Only applying this to the first declaration seems problematic, as
9222 // simple reorderings can affect the meaning of the program.
9223 if (First && !FD->isConstexpr() && Info.Constexpr)
9225
9226 // C++2a [except.spec]p3:
9227 // If a declaration of a function does not have a noexcept-specifier
9228 // [and] is defaulted on its first declaration, [...] the exception
9229 // specification is as specified below
9230 if (FD->getExceptionSpecType() == EST_None) {
9231 auto *FPT = FD->getType()->castAs<FunctionProtoType>();
9232 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
9234 EPI.ExceptionSpec.SourceDecl = FD;
9235 FD->setType(Context.getFunctionType(FPT->getReturnType(),
9236 FPT->getParamTypes(), EPI));
9237 }
9238
9239 return false;
9240}
9241
9243 FunctionDecl *Spaceship) {
9246 Ctx.PointOfInstantiation = Spaceship->getEndLoc();
9247 Ctx.Entity = Spaceship;
9249
9250 if (FunctionDecl *EqualEqual = SubstSpaceshipAsEqualEqual(RD, Spaceship))
9251 EqualEqual->setImplicit();
9252
9254}
9255
9258 assert(FD->isDefaulted() && !FD->isDeleted() &&
9260 if (FD->willHaveBody() || FD->isInvalidDecl())
9261 return;
9262
9264
9265 // Add a context note for diagnostics produced after this point.
9266 Scope.addContextNote(UseLoc);
9267
9268 {
9269 // Build and set up the function body.
9270 // The first parameter has type maybe-ref-to maybe-const T, use that to get
9271 // the type of the class being compared.
9272 auto PT = FD->getParamDecl(0)->getType();
9273 CXXRecordDecl *RD = PT.getNonReferenceType()->getAsCXXRecordDecl();
9274 SourceLocation BodyLoc =
9275 FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
9276 StmtResult Body =
9277 DefaultedComparisonSynthesizer(*this, RD, FD, DCK, BodyLoc).build();
9278 if (Body.isInvalid()) {
9279 FD->setInvalidDecl();
9280 return;
9281 }
9282 FD->setBody(Body.get());
9283 FD->markUsed(Context);
9284 }
9285
9286 // The exception specification is needed because we are defining the
9287 // function. Note that this will reuse the body we just built.
9289
9291 L->CompletedImplicitDefinition(FD);
9292}
9293
9296 FunctionDecl *FD,
9298 ComputingExceptionSpec CES(S, FD, Loc);
9300
9301 if (FD->isInvalidDecl())
9302 return ExceptSpec;
9303
9304 // The common case is that we just defined the comparison function. In that
9305 // case, just look at whether the body can throw.
9306 if (FD->hasBody()) {
9307 ExceptSpec.CalledStmt(FD->getBody());
9308 } else {
9309 // Otherwise, build a body so we can check it. This should ideally only
9310 // happen when we're not actually marking the function referenced. (This is
9311 // only really important for efficiency: we don't want to build and throw
9312 // away bodies for comparison functions more than we strictly need to.)
9313
9314 // Pretend to synthesize the function body in an unevaluated context.
9315 // Note that we can't actually just go ahead and define the function here:
9316 // we are not permitted to mark its callees as referenced.
9320
9321 CXXRecordDecl *RD =
9322 cast<CXXRecordDecl>(FD->getFriendObjectKind() == Decl::FOK_None
9323 ? FD->getDeclContext()
9324 : FD->getLexicalDeclContext());
9325 SourceLocation BodyLoc =
9326 FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
9327 StmtResult Body =
9328 DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
9329 if (!Body.isInvalid())
9330 ExceptSpec.CalledStmt(Body.get());
9331
9332 // FIXME: Can we hold onto this body and just transform it to potentially
9333 // evaluated when we're asked to define the function rather than rebuilding
9334 // it? Either that, or we should only build the bits of the body that we
9335 // need (the expressions, not the statements).
9336 }
9337
9338 return ExceptSpec;
9339}
9340
9342 decltype(DelayedOverridingExceptionSpecChecks) Overriding;
9344
9345 std::swap(Overriding, DelayedOverridingExceptionSpecChecks);
9347
9348 // Perform any deferred checking of exception specifications for virtual
9349 // destructors.
9350 for (auto &Check : Overriding)
9351 CheckOverridingFunctionExceptionSpec(Check.first, Check.second);
9352
9353 // Perform any deferred checking of exception specifications for befriended
9354 // special members.
9355 for (auto &Check : Equivalent)
9356 CheckEquivalentExceptionSpec(Check.second, Check.first);
9357}
9358
9359namespace {
9360/// CRTP base class for visiting operations performed by a special member
9361/// function (or inherited constructor).
9362template<typename Derived>
9363struct SpecialMemberVisitor {
9364 Sema &S;
9365 CXXMethodDecl *MD;
9368
9369 // Properties of the special member, computed for convenience.
9370 bool IsConstructor = false, IsAssignment = false, ConstArg = false;
9371
9372 SpecialMemberVisitor(Sema &S, CXXMethodDecl *MD, CXXSpecialMemberKind CSM,
9374 : S(S), MD(MD), CSM(CSM), ICI(ICI) {
9375 switch (CSM) {
9376 case CXXSpecialMemberKind::DefaultConstructor:
9377 case CXXSpecialMemberKind::CopyConstructor:
9378 case CXXSpecialMemberKind::MoveConstructor:
9379 IsConstructor = true;
9380 break;
9381 case CXXSpecialMemberKind::CopyAssignment:
9382 case CXXSpecialMemberKind::MoveAssignment:
9383 IsAssignment = true;
9384 break;
9385 case CXXSpecialMemberKind::Destructor:
9386 break;
9387 case CXXSpecialMemberKind::Invalid:
9388 llvm_unreachable("invalid special member kind");
9389 }
9390
9391 if (MD->getNumExplicitParams()) {
9392 if (const ReferenceType *RT =
9394 ConstArg = RT->getPointeeType().isConstQualified();
9395 }
9396 }
9397
9398 Derived &getDerived() { return static_cast<Derived&>(*this); }
9399
9400 /// Is this a "move" special member?
9401 bool isMove() const {
9402 return CSM == CXXSpecialMemberKind::MoveConstructor ||
9403 CSM == CXXSpecialMemberKind::MoveAssignment;
9404 }
9405
9406 /// Look up the corresponding special member in the given class.
9408 unsigned Quals, bool IsMutable) {
9409 return lookupCallFromSpecialMember(S, Class, CSM, Quals,
9410 ConstArg && !IsMutable);
9411 }
9412
9413 /// Look up the constructor for the specified base class to see if it's
9414 /// overridden due to this being an inherited constructor.
9415 Sema::SpecialMemberOverloadResult lookupInheritedCtor(CXXRecordDecl *Class) {
9416 if (!ICI)
9417 return {};
9418 assert(CSM == CXXSpecialMemberKind::DefaultConstructor);
9419 auto *BaseCtor =
9420 cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
9421 if (auto *MD = ICI->findConstructorForBase(Class, BaseCtor).first)
9422 return MD;
9423 return {};
9424 }
9425
9426 /// A base or member subobject.
9427 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
9428
9429 /// Get the location to use for a subobject in diagnostics.
9430 static SourceLocation getSubobjectLoc(Subobject Subobj) {
9431 // FIXME: For an indirect virtual base, the direct base leading to
9432 // the indirect virtual base would be a more useful choice.
9433 if (auto *B = dyn_cast<CXXBaseSpecifier *>(Subobj))
9434 return B->getBaseTypeLoc();
9435 else
9436 return cast<FieldDecl *>(Subobj)->getLocation();
9437 }
9438
9439 enum BasesToVisit {
9440 /// Visit all non-virtual (direct) bases.
9441 VisitNonVirtualBases,
9442 /// Visit all direct bases, virtual or not.
9443 VisitDirectBases,
9444 /// Visit all non-virtual bases, and all virtual bases if the class
9445 /// is not abstract.
9446 VisitPotentiallyConstructedBases,
9447 /// Visit all direct or virtual bases.
9448 VisitAllBases
9449 };
9450
9451 // Visit the bases and members of the class.
9452 bool visit(BasesToVisit Bases) {
9453 CXXRecordDecl *RD = MD->getParent();
9454
9455 if (Bases == VisitPotentiallyConstructedBases)
9456 Bases = RD->isAbstract() ? VisitNonVirtualBases : VisitAllBases;
9457
9458 for (auto &B : RD->bases())
9459 if ((Bases == VisitDirectBases || !B.isVirtual()) &&
9460 getDerived().visitBase(&B))
9461 return true;
9462
9463 if (Bases == VisitAllBases)
9464 for (auto &B : RD->vbases())
9465 if (getDerived().visitBase(&B))
9466 return true;
9467
9468 for (auto *F : RD->fields())
9469 if (!F->isInvalidDecl() && !F->isUnnamedBitField() &&
9470 getDerived().visitField(F))
9471 return true;
9472
9473 return false;
9474 }
9475};
9476}
9477
9478namespace {
9479struct SpecialMemberDeletionInfo
9480 : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
9481 bool Diagnose;
9482
9484
9485 bool AllFieldsAreConst;
9486
9487 SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
9489 Sema::InheritedConstructorInfo *ICI, bool Diagnose)
9490 : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
9491 Loc(MD->getLocation()), AllFieldsAreConst(true) {}
9492
9493 bool inUnion() const { return MD->getParent()->isUnion(); }
9494
9495 CXXSpecialMemberKind getEffectiveCSM() {
9496 return ICI ? CXXSpecialMemberKind::Invalid : CSM;
9497 }
9498
9499 bool shouldDeleteForVariantObjCPtrMember(FieldDecl *FD, QualType FieldType);
9500
9501 bool shouldDeleteForVariantPtrAuthMember(const FieldDecl *FD);
9502
9503 bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
9504 bool visitField(FieldDecl *Field) { return shouldDeleteForField(Field); }
9505
9506 bool shouldDeleteForBase(CXXBaseSpecifier *Base);
9507 bool shouldDeleteForField(FieldDecl *FD);
9508 bool shouldDeleteForAllConstMembers();
9509
9510 bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
9511 unsigned Quals);
9512 bool shouldDeleteForSubobjectCall(Subobject Subobj,
9514 bool IsDtorCallInCtor);
9515
9516 bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
9517};
9518}
9519
9520/// Is the given special member inaccessible when used on the given
9521/// sub-object.
9522bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
9523 CXXMethodDecl *target) {
9524 /// If we're operating on a base class, the object type is the
9525 /// type of this special member.
9526 CanQualType objectTy;
9527 AccessSpecifier access = target->getAccess();
9528 if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
9529 objectTy = S.Context.getCanonicalTagType(MD->getParent());
9530 access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
9531
9532 // If we're operating on a field, the object type is the type of the field.
9533 } else {
9534 objectTy = S.Context.getCanonicalTagType(target->getParent());
9535 }
9536
9538 target->getParent(), DeclAccessPair::make(target, access), objectTy);
9539}
9540
9541/// Check whether we should delete a special member due to the implicit
9542/// definition containing a call to a special member of a subobject.
9543bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
9544 Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR,
9545 bool IsDtorCallInCtor) {
9546 CXXMethodDecl *Decl = SMOR.getMethod();
9547 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
9548
9549 int DiagKind = -1;
9550
9552 DiagKind = !Decl ? 0 : 1;
9554 DiagKind = 2;
9555 else if (!isAccessible(Subobj, Decl))
9556 DiagKind = 3;
9557 else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
9558 !Decl->isTrivial()) {
9559 // A member of a union must have a trivial corresponding special member.
9560 // As a weird special case, a destructor call from a union's constructor
9561 // must be accessible and non-deleted, but need not be trivial. Such a
9562 // destructor is never actually called, but is semantically checked as
9563 // if it were.
9565 // [class.default.ctor]p2:
9566 // A defaulted default constructor for class X is defined as deleted if
9567 // - X is a union that has a variant member with a non-trivial default
9568 // constructor and no variant member of X has a default member
9569 // initializer
9570 const auto *RD = cast<CXXRecordDecl>(Field->getParent());
9571 if (!RD->hasInClassInitializer())
9572 DiagKind = 4;
9573 } else {
9574 DiagKind = 4;
9575 }
9576 }
9577
9578 if (DiagKind == -1)
9579 return false;
9580
9581 if (Diagnose) {
9582 if (Field) {
9583 S.Diag(Field->getLocation(),
9584 diag::note_deleted_special_member_class_subobject)
9585 << getEffectiveCSM() << MD->getParent() << /*IsField*/ true << Field
9586 << DiagKind << IsDtorCallInCtor << /*IsObjCPtr*/ false;
9587 } else {
9588 CXXBaseSpecifier *Base = cast<CXXBaseSpecifier *>(Subobj);
9589 S.Diag(Base->getBeginLoc(),
9590 diag::note_deleted_special_member_class_subobject)
9591 << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
9592 << Base->getType() << DiagKind << IsDtorCallInCtor
9593 << /*IsObjCPtr*/ false;
9594 }
9595
9596 if (DiagKind == 1)
9598 // FIXME: Explain inaccessibility if DiagKind == 3.
9599 }
9600
9601 return true;
9602}
9603
9604/// Check whether we should delete a special member function due to having a
9605/// direct or virtual base class or non-static data member of class type M.
9606bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
9607 CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
9608 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
9609 bool IsMutable = Field && Field->isMutable();
9610
9611 // C++11 [class.ctor]p5:
9612 // -- any direct or virtual base class, or non-static data member with no
9613 // brace-or-equal-initializer, has class type M (or array thereof) and
9614 // either M has no default constructor or overload resolution as applied
9615 // to M's default constructor results in an ambiguity or in a function
9616 // that is deleted or inaccessible
9617 // C++11 [class.copy]p11, C++11 [class.copy]p23:
9618 // -- a direct or virtual base class B that cannot be copied/moved because
9619 // overload resolution, as applied to B's corresponding special member,
9620 // results in an ambiguity or a function that is deleted or inaccessible
9621 // from the defaulted special member
9622 // C++11 [class.dtor]p5:
9623 // -- any direct or virtual base class [...] has a type with a destructor
9624 // that is deleted or inaccessible
9625 if (!(CSM == CXXSpecialMemberKind::DefaultConstructor && Field &&
9626 Field->hasInClassInitializer()) &&
9627 shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
9628 false))
9629 return true;
9630
9631 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
9632 // -- any direct or virtual base class or non-static data member has a
9633 // type with a destructor that is deleted or inaccessible
9634 if (IsConstructor) {
9637 false, false, false, false);
9638 if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
9639 return true;
9640 }
9641
9642 return false;
9643}
9644
9645bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
9646 FieldDecl *FD, QualType FieldType) {
9647 // The defaulted special functions are defined as deleted if this is a variant
9648 // member with a non-trivial ownership type, e.g., ObjC __strong or __weak
9649 // type under ARC.
9650 if (!FieldType.hasNonTrivialObjCLifetime())
9651 return false;
9652
9653 // Don't make the defaulted default constructor defined as deleted if the
9654 // member has an in-class initializer.
9657 return false;
9658
9659 if (Diagnose) {
9660 auto *ParentClass = cast<CXXRecordDecl>(FD->getParent());
9661 S.Diag(FD->getLocation(), diag::note_deleted_special_member_class_subobject)
9662 << getEffectiveCSM() << ParentClass << /*IsField*/ true << FD << 4
9663 << /*IsDtorCallInCtor*/ false << /*IsObjCPtr*/ true;
9664 }
9665
9666 return true;
9667}
9668
9669bool SpecialMemberDeletionInfo::shouldDeleteForVariantPtrAuthMember(
9670 const FieldDecl *FD) {
9671 QualType FieldType = S.Context.getBaseElementType(FD->getType());
9672 // Copy/move constructors/assignment operators are deleted if the field has an
9673 // address-discriminated ptrauth qualifier.
9674 PointerAuthQualifier Q = FieldType.getPointerAuth();
9675
9676 if (!Q || !Q.isAddressDiscriminated())
9677 return false;
9678
9681 return false;
9682
9683 if (Diagnose) {
9684 auto *ParentClass = cast<CXXRecordDecl>(FD->getParent());
9685 S.Diag(FD->getLocation(), diag::note_deleted_special_member_class_subobject)
9686 << getEffectiveCSM() << ParentClass << /*IsField*/ true << FD << 4
9687 << /*IsDtorCallInCtor*/ false << 2;
9688 }
9689
9690 return true;
9691}
9692
9693/// Check whether we should delete a special member function due to the class
9694/// having a particular direct or virtual base class.
9695bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
9696 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
9697 // If program is correct, BaseClass cannot be null, but if it is, the error
9698 // must be reported elsewhere.
9699 if (!BaseClass)
9700 return false;
9701 // If we have an inheriting constructor, check whether we're calling an
9702 // inherited constructor instead of a default constructor.
9703 Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
9704 if (auto *BaseCtor = SMOR.getMethod()) {
9705 // Note that we do not check access along this path; other than that,
9706 // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
9707 // FIXME: Check that the base has a usable destructor! Sink this into
9708 // shouldDeleteForClassSubobject.
9709 if (BaseCtor->isDeleted() && Diagnose) {
9710 S.Diag(Base->getBeginLoc(),
9711 diag::note_deleted_special_member_class_subobject)
9712 << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
9713 << Base->getType() << /*Deleted*/ 1 << /*IsDtorCallInCtor*/ false
9714 << /*IsObjCPtr*/ false;
9715 S.NoteDeletedFunction(BaseCtor);
9716 }
9717 return BaseCtor->isDeleted();
9718 }
9719 return shouldDeleteForClassSubobject(BaseClass, Base, 0);
9720}
9721
9722/// Check whether we should delete a special member function due to the class
9723/// having a particular non-static data member.
9724bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
9725 QualType FieldType = S.Context.getBaseElementType(FD->getType());
9726 CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
9727
9728 if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
9729 return true;
9730
9731 if (inUnion() && shouldDeleteForVariantPtrAuthMember(FD))
9732 return true;
9733
9735 // For a default constructor, all references must be initialized in-class
9736 // and, if a union, it must have a non-const member.
9737 if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
9738 if (Diagnose)
9739 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
9740 << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
9741 return true;
9742 }
9743 // C++11 [class.ctor]p5 (modified by DR2394): any non-variant non-static
9744 // data member of const-qualified type (or array thereof) with no
9745 // brace-or-equal-initializer is not const-default-constructible.
9746 if (!inUnion() && FieldType.isConstQualified() &&
9747 !FD->hasInClassInitializer() &&
9748 (!FieldRecord || !FieldRecord->allowConstDefaultInit())) {
9749 if (Diagnose)
9750 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
9751 << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
9752 return true;
9753 }
9754
9755 if (inUnion() && !FieldType.isConstQualified())
9756 AllFieldsAreConst = false;
9757 } else if (CSM == CXXSpecialMemberKind::CopyConstructor) {
9758 // For a copy constructor, data members must not be of rvalue reference
9759 // type.
9760 if (FieldType->isRValueReferenceType()) {
9761 if (Diagnose)
9762 S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
9763 << MD->getParent() << FD << FieldType;
9764 return true;
9765 }
9766 } else if (IsAssignment) {
9767 // For an assignment operator, data members must not be of reference type.
9768 if (FieldType->isReferenceType()) {
9769 if (Diagnose)
9770 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
9771 << isMove() << MD->getParent() << FD << FieldType << /*Reference*/0;
9772 return true;
9773 }
9774 if (!FieldRecord && FieldType.isConstQualified()) {
9775 // C++11 [class.copy]p23:
9776 // -- a non-static data member of const non-class type (or array thereof)
9777 if (Diagnose)
9778 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
9779 << isMove() << MD->getParent() << FD << FD->getType() << /*Const*/1;
9780 return true;
9781 }
9782 }
9783
9784 if (FieldRecord) {
9785 // Some additional restrictions exist on the variant members.
9786 if (!inUnion() && FieldRecord->isUnion() &&
9787 FieldRecord->isAnonymousStructOrUnion()) {
9788 bool AllVariantFieldsAreConst = true;
9789
9790 // FIXME: Handle anonymous unions declared within anonymous unions.
9791 for (auto *UI : FieldRecord->fields()) {
9792 QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
9793
9794 if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
9795 return true;
9796
9797 if (shouldDeleteForVariantPtrAuthMember(&*UI))
9798 return true;
9799
9800 if (!UnionFieldType.isConstQualified())
9801 AllVariantFieldsAreConst = false;
9802
9803 CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
9804 if (UnionFieldRecord &&
9805 shouldDeleteForClassSubobject(UnionFieldRecord, UI,
9806 UnionFieldType.getCVRQualifiers()))
9807 return true;
9808 }
9809
9810 // At least one member in each anonymous union must be non-const
9812 AllVariantFieldsAreConst && !FieldRecord->field_empty()) {
9813 if (Diagnose)
9814 S.Diag(FieldRecord->getLocation(),
9815 diag::note_deleted_default_ctor_all_const)
9816 << !!ICI << MD->getParent() << /*anonymous union*/1;
9817 return true;
9818 }
9819
9820 // Don't check the implicit member of the anonymous union type.
9821 // This is technically non-conformant but supported, and we have a
9822 // diagnostic for this elsewhere.
9823 return false;
9824 }
9825
9826 if (shouldDeleteForClassSubobject(FieldRecord, FD,
9827 FieldType.getCVRQualifiers()))
9828 return true;
9829 }
9830
9831 return false;
9832}
9833
9834/// C++11 [class.ctor] p5:
9835/// A defaulted default constructor for a class X is defined as deleted if
9836/// X is a union and all of its variant members are of const-qualified type.
9837bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
9838 // This is a silly definition, because it gives an empty union a deleted
9839 // default constructor. Don't do that.
9840 if (CSM == CXXSpecialMemberKind::DefaultConstructor && inUnion() &&
9841 AllFieldsAreConst) {
9842 bool AnyFields = false;
9843 for (auto *F : MD->getParent()->fields())
9844 if ((AnyFields = !F->isUnnamedBitField()))
9845 break;
9846 if (!AnyFields)
9847 return false;
9848 if (Diagnose)
9849 S.Diag(MD->getParent()->getLocation(),
9850 diag::note_deleted_default_ctor_all_const)
9851 << !!ICI << MD->getParent() << /*not anonymous union*/0;
9852 return true;
9853 }
9854 return false;
9855}
9856
9857/// Determine whether a defaulted special member function should be defined as
9858/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
9859/// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
9863 bool Diagnose) {
9864 if (MD->isInvalidDecl())
9865 return false;
9866 CXXRecordDecl *RD = MD->getParent();
9867 assert(!RD->isDependentType() && "do deletion after instantiation");
9868 if (!LangOpts.CPlusPlus || (!LangOpts.CPlusPlus11 && !RD->isLambda()) ||
9869 RD->isInvalidDecl())
9870 return false;
9871
9872 // C++11 [expr.lambda.prim]p19:
9873 // The closure type associated with a lambda-expression has a
9874 // deleted (8.4.3) default constructor and a deleted copy
9875 // assignment operator.
9876 // C++2a adds back these operators if the lambda has no lambda-capture.
9880 if (Diagnose)
9881 Diag(RD->getLocation(), diag::note_lambda_decl);
9882 return true;
9883 }
9884
9885 // For an anonymous struct or union, the copy and assignment special members
9886 // will never be used, so skip the check. For an anonymous union declared at
9887 // namespace scope, the constructor and destructor are used.
9890 return false;
9891
9892 // C++11 [class.copy]p7, p18:
9893 // If the class definition declares a move constructor or move assignment
9894 // operator, an implicitly declared copy constructor or copy assignment
9895 // operator is defined as deleted.
9898 CXXMethodDecl *UserDeclaredMove = nullptr;
9899
9900 // In Microsoft mode up to MSVC 2013, a user-declared move only causes the
9901 // deletion of the corresponding copy operation, not both copy operations.
9902 // MSVC 2015 has adopted the standards conforming behavior.
9903 bool DeletesOnlyMatchingCopy =
9904 getLangOpts().MSVCCompat &&
9906
9908 (!DeletesOnlyMatchingCopy ||
9910 if (!Diagnose) return true;
9911
9912 // Find any user-declared move constructor.
9913 for (auto *I : RD->ctors()) {
9914 if (I->isMoveConstructor()) {
9915 UserDeclaredMove = I;
9916 break;
9917 }
9918 }
9919 assert(UserDeclaredMove);
9920 } else if (RD->hasUserDeclaredMoveAssignment() &&
9921 (!DeletesOnlyMatchingCopy ||
9923 if (!Diagnose) return true;
9924
9925 // Find any user-declared move assignment operator.
9926 for (auto *I : RD->methods()) {
9927 if (I->isMoveAssignmentOperator()) {
9928 UserDeclaredMove = I;
9929 break;
9930 }
9931 }
9932 assert(UserDeclaredMove);
9933 }
9934
9935 if (UserDeclaredMove) {
9936 Diag(UserDeclaredMove->getLocation(),
9937 diag::note_deleted_copy_user_declared_move)
9938 << (CSM == CXXSpecialMemberKind::CopyAssignment) << RD
9939 << UserDeclaredMove->isMoveAssignmentOperator();
9940 return true;
9941 }
9942 }
9943
9944 // Do access control from the special member function
9945 ContextRAII MethodContext(*this, MD);
9946
9947 // C++11 [class.dtor]p5:
9948 // -- for a virtual destructor, lookup of the non-array deallocation function
9949 // results in an ambiguity or in a function that is deleted or inaccessible
9950 if (CSM == CXXSpecialMemberKind::Destructor && MD->isVirtual()) {
9951 FunctionDecl *OperatorDelete = nullptr;
9952 CanQualType DeallocType = Context.getCanonicalTagType(RD);
9953 DeclarationName Name =
9958 if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
9959 OperatorDelete, IDP,
9960 /*Diagnose=*/false)) {
9961 if (Diagnose)
9962 Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
9963 return true;
9964 }
9965 }
9966
9967 SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
9968
9969 // Per DR1611, do not consider virtual bases of constructors of abstract
9970 // classes, since we are not going to construct them.
9971 // Per DR1658, do not consider virtual bases of destructors of abstract
9972 // classes either.
9973 // Per DR2180, for assignment operators we only assign (and thus only
9974 // consider) direct bases.
9975 if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
9976 : SMI.VisitPotentiallyConstructedBases))
9977 return true;
9978
9979 if (SMI.shouldDeleteForAllConstMembers())
9980 return true;
9981
9982 if (getLangOpts().CUDA) {
9983 // We should delete the special member in CUDA mode if target inference
9984 // failed.
9985 // For inherited constructors (non-null ICI), CSM may be passed so that MD
9986 // is treated as certain special member, which may not reflect what special
9987 // member MD really is. However inferTargetForImplicitSpecialMember
9988 // expects CSM to match MD, therefore recalculate CSM.
9989 assert(ICI || CSM == getSpecialMember(MD));
9990 auto RealCSM = CSM;
9991 if (ICI)
9992 RealCSM = getSpecialMember(MD);
9993
9994 return CUDA().inferTargetForImplicitSpecialMember(RD, RealCSM, MD,
9995 SMI.ConstArg, Diagnose);
9996 }
9997
9998 return false;
9999}
10000
10003 assert(DFK && "not a defaultable function");
10004 assert(FD->isDefaulted() && FD->isDeleted() && "not defaulted and deleted");
10005
10006 if (DFK.isSpecialMember()) {
10007 ShouldDeleteSpecialMember(cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),
10008 nullptr, /*Diagnose=*/true);
10009 } else {
10010 DefaultedComparisonAnalyzer(
10011 *this, cast<CXXRecordDecl>(FD->getLexicalDeclContext()), FD,
10012 DFK.asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
10013 .visit();
10014 }
10015}
10016
10017/// Perform lookup for a special member of the specified kind, and determine
10018/// whether it is trivial. If the triviality can be determined without the
10019/// lookup, skip it. This is intended for use when determining whether a
10020/// special member of a containing object is trivial, and thus does not ever
10021/// perform overload resolution for default constructors.
10022///
10023/// If \p Selected is not \c NULL, \c *Selected will be filled in with the
10024/// member that was most likely to be intended to be trivial, if any.
10025///
10026/// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
10027/// determine whether the special member is trivial.
10029 CXXSpecialMemberKind CSM, unsigned Quals,
10030 bool ConstRHS, TrivialABIHandling TAH,
10031 CXXMethodDecl **Selected) {
10032 if (Selected)
10033 *Selected = nullptr;
10034
10035 switch (CSM) {
10037 llvm_unreachable("not a special member");
10038
10040 // C++11 [class.ctor]p5:
10041 // A default constructor is trivial if:
10042 // - all the [direct subobjects] have trivial default constructors
10043 //
10044 // Note, no overload resolution is performed in this case.
10046 return true;
10047
10048 if (Selected) {
10049 // If there's a default constructor which could have been trivial, dig it
10050 // out. Otherwise, if there's any user-provided default constructor, point
10051 // to that as an example of why there's not a trivial one.
10052 CXXConstructorDecl *DefCtor = nullptr;
10055 for (auto *CI : RD->ctors()) {
10056 if (!CI->isDefaultConstructor())
10057 continue;
10058 DefCtor = CI;
10059 if (!DefCtor->isUserProvided())
10060 break;
10061 }
10062
10063 *Selected = DefCtor;
10064 }
10065
10066 return false;
10067
10069 // C++11 [class.dtor]p5:
10070 // A destructor is trivial if:
10071 // - all the direct [subobjects] have trivial destructors
10072 if (RD->hasTrivialDestructor() ||
10075 return true;
10076
10077 if (Selected) {
10078 if (RD->needsImplicitDestructor())
10080 *Selected = RD->getDestructor();
10081 }
10082
10083 return false;
10084
10086 // C++11 [class.copy]p12:
10087 // A copy constructor is trivial if:
10088 // - the constructor selected to copy each direct [subobject] is trivial
10089 if (RD->hasTrivialCopyConstructor() ||
10092 if (Quals == Qualifiers::Const)
10093 // We must either select the trivial copy constructor or reach an
10094 // ambiguity; no need to actually perform overload resolution.
10095 return true;
10096 } else if (!Selected) {
10097 return false;
10098 }
10099 // In C++98, we are not supposed to perform overload resolution here, but we
10100 // treat that as a language defect, as suggested on cxx-abi-dev, to treat
10101 // cases like B as having a non-trivial copy constructor:
10102 // struct A { template<typename T> A(T&); };
10103 // struct B { mutable A a; };
10104 goto NeedOverloadResolution;
10105
10107 // C++11 [class.copy]p25:
10108 // A copy assignment operator is trivial if:
10109 // - the assignment operator selected to copy each direct [subobject] is
10110 // trivial
10111 if (RD->hasTrivialCopyAssignment()) {
10112 if (Quals == Qualifiers::Const)
10113 return true;
10114 } else if (!Selected) {
10115 return false;
10116 }
10117 // In C++98, we are not supposed to perform overload resolution here, but we
10118 // treat that as a language defect.
10119 goto NeedOverloadResolution;
10120
10123 NeedOverloadResolution:
10125 lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
10126
10127 // The standard doesn't describe how to behave if the lookup is ambiguous.
10128 // We treat it as not making the member non-trivial, just like the standard
10129 // mandates for the default constructor. This should rarely matter, because
10130 // the member will also be deleted.
10132 return true;
10133
10134 if (!SMOR.getMethod()) {
10135 assert(SMOR.getKind() ==
10137 return false;
10138 }
10139
10140 // We deliberately don't check if we found a deleted special member. We're
10141 // not supposed to!
10142 if (Selected)
10143 *Selected = SMOR.getMethod();
10144
10148 return SMOR.getMethod()->isTrivialForCall();
10149 return SMOR.getMethod()->isTrivial();
10150 }
10151
10152 llvm_unreachable("unknown special method kind");
10153}
10154
10156 for (auto *CI : RD->ctors())
10157 if (!CI->isImplicit())
10158 return CI;
10159
10160 // Look for constructor templates.
10162 for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
10163 if (CXXConstructorDecl *CD =
10164 dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
10165 return CD;
10166 }
10167
10168 return nullptr;
10169}
10170
10171/// The kind of subobject we are checking for triviality. The values of this
10172/// enumeration are used in diagnostics.
10174 /// The subobject is a base class.
10176 /// The subobject is a non-static data member.
10178 /// The object is actually the complete object.
10181
10182/// Check whether the special member selected for a given type would be trivial.
10184 QualType SubType, bool ConstRHS,
10187 TrivialABIHandling TAH, bool Diagnose) {
10188 CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
10189 if (!SubRD)
10190 return true;
10191
10192 CXXMethodDecl *Selected;
10193 if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
10194 ConstRHS, TAH, Diagnose ? &Selected : nullptr))
10195 return true;
10196
10197 if (Diagnose) {
10198 if (ConstRHS)
10199 SubType.addConst();
10200
10201 if (!Selected && CSM == CXXSpecialMemberKind::DefaultConstructor) {
10202 S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
10203 << Kind << SubType.getUnqualifiedType();
10205 S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
10206 } else if (!Selected)
10207 S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
10208 << Kind << SubType.getUnqualifiedType() << CSM << SubType;
10209 else if (Selected->isUserProvided()) {
10210 if (Kind == TSK_CompleteObject)
10211 S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
10212 << Kind << SubType.getUnqualifiedType() << CSM;
10213 else {
10214 S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
10215 << Kind << SubType.getUnqualifiedType() << CSM;
10216 S.Diag(Selected->getLocation(), diag::note_declared_at);
10217 }
10218 } else {
10219 if (Kind != TSK_CompleteObject)
10220 S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
10221 << Kind << SubType.getUnqualifiedType() << CSM;
10222
10223 // Explain why the defaulted or deleted special member isn't trivial.
10224 S.SpecialMemberIsTrivial(Selected, CSM,
10226 }
10227 }
10228
10229 return false;
10230}
10231
10232/// Check whether the members of a class type allow a special member to be
10233/// trivial.
10235 CXXSpecialMemberKind CSM, bool ConstArg,
10236 TrivialABIHandling TAH, bool Diagnose) {
10237 for (const auto *FI : RD->fields()) {
10238 if (FI->isInvalidDecl() || FI->isUnnamedBitField())
10239 continue;
10240
10241 QualType FieldType = S.Context.getBaseElementType(FI->getType());
10242
10243 // Pretend anonymous struct or union members are members of this class.
10244 if (FI->isAnonymousStructOrUnion()) {
10245 if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
10246 CSM, ConstArg, TAH, Diagnose))
10247 return false;
10248 continue;
10249 }
10250
10251 // C++11 [class.ctor]p5:
10252 // A default constructor is trivial if [...]
10253 // -- no non-static data member of its class has a
10254 // brace-or-equal-initializer
10256 FI->hasInClassInitializer()) {
10257 if (Diagnose)
10258 S.Diag(FI->getLocation(), diag::note_nontrivial_default_member_init)
10259 << FI;
10260 return false;
10261 }
10262
10263 // Objective C ARC 4.3.5:
10264 // [...] nontrivally ownership-qualified types are [...] not trivially
10265 // default constructible, copy constructible, move constructible, copy
10266 // assignable, move assignable, or destructible [...]
10267 if (FieldType.hasNonTrivialObjCLifetime()) {
10268 if (Diagnose)
10269 S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
10270 << RD << FieldType.getObjCLifetime();
10271 return false;
10272 }
10273
10274 bool ConstRHS = ConstArg && !FI->isMutable();
10275 if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
10276 CSM, TSK_Field, TAH, Diagnose))
10277 return false;
10278 }
10279
10280 return true;
10281}
10282
10286
10287 bool ConstArg = (CSM == CXXSpecialMemberKind::CopyConstructor ||
10289 checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
10292 /*Diagnose*/ true);
10293}
10294
10296 TrivialABIHandling TAH, bool Diagnose) {
10297 assert(!MD->isUserProvided() && CSM != CXXSpecialMemberKind::Invalid &&
10298 "not special enough");
10299
10300 CXXRecordDecl *RD = MD->getParent();
10301
10302 bool ConstArg = false;
10303
10304 // C++11 [class.copy]p12, p25: [DR1593]
10305 // A [special member] is trivial if [...] its parameter-type-list is
10306 // equivalent to the parameter-type-list of an implicit declaration [...]
10307 switch (CSM) {
10310 // Trivial default constructors and destructors cannot have parameters.
10311 break;
10312
10315 const ParmVarDecl *Param0 = MD->getNonObjectParameter(0);
10316 const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
10317
10318 // When ClangABICompat14 is true, CXX copy constructors will only be trivial
10319 // if they are not user-provided and their parameter-type-list is equivalent
10320 // to the parameter-type-list of an implicit declaration. This maintains the
10321 // behavior before dr2171 was implemented.
10322 //
10323 // Otherwise, if ClangABICompat14 is false, All copy constructors can be
10324 // trivial, if they are not user-provided, regardless of the qualifiers on
10325 // the reference type.
10326 const bool ClangABICompat14 = Context.getLangOpts().getClangABICompat() <=
10327 LangOptions::ClangABI::Ver14;
10328 if (!RT ||
10330 ClangABICompat14)) {
10331 if (Diagnose)
10332 Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
10333 << Param0->getSourceRange() << Param0->getType()
10336 return false;
10337 }
10338
10339 ConstArg = RT->getPointeeType().isConstQualified();
10340 break;
10341 }
10342
10345 // Trivial move operations always have non-cv-qualified parameters.
10346 const ParmVarDecl *Param0 = MD->getNonObjectParameter(0);
10347 const RValueReferenceType *RT =
10348 Param0->getType()->getAs<RValueReferenceType>();
10349 if (!RT || RT->getPointeeType().getCVRQualifiers()) {
10350 if (Diagnose)
10351 Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
10352 << Param0->getSourceRange() << Param0->getType()
10354 return false;
10355 }
10356 break;
10357 }
10358
10360 llvm_unreachable("not a special member");
10361 }
10362
10363 if (MD->getMinRequiredArguments() < MD->getNumParams()) {
10364 if (Diagnose)
10366 diag::note_nontrivial_default_arg)
10368 return false;
10369 }
10370 if (MD->isVariadic()) {
10371 if (Diagnose)
10372 Diag(MD->getLocation(), diag::note_nontrivial_variadic);
10373 return false;
10374 }
10375
10376 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
10377 // A copy/move [constructor or assignment operator] is trivial if
10378 // -- the [member] selected to copy/move each direct base class subobject
10379 // is trivial
10380 //
10381 // C++11 [class.copy]p12, C++11 [class.copy]p25:
10382 // A [default constructor or destructor] is trivial if
10383 // -- all the direct base classes have trivial [default constructors or
10384 // destructors]
10385 for (const auto &BI : RD->bases())
10386 if (!checkTrivialSubobjectCall(*this, BI.getBeginLoc(), BI.getType(),
10387 ConstArg, CSM, TSK_BaseClass, TAH, Diagnose))
10388 return false;
10389
10390 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
10391 // A copy/move [constructor or assignment operator] for a class X is
10392 // trivial if
10393 // -- for each non-static data member of X that is of class type (or array
10394 // thereof), the constructor selected to copy/move that member is
10395 // trivial
10396 //
10397 // C++11 [class.copy]p12, C++11 [class.copy]p25:
10398 // A [default constructor or destructor] is trivial if
10399 // -- for all of the non-static data members of its class that are of class
10400 // type (or array thereof), each such class has a trivial [default
10401 // constructor or destructor]
10402 if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, TAH, Diagnose))
10403 return false;
10404
10405 // C++11 [class.dtor]p5:
10406 // A destructor is trivial if [...]
10407 // -- the destructor is not virtual
10408 if (CSM == CXXSpecialMemberKind::Destructor && MD->isVirtual()) {
10409 if (Diagnose)
10410 Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
10411 return false;
10412 }
10413
10414 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
10415 // A [special member] for class X is trivial if [...]
10416 // -- class X has no virtual functions and no virtual base classes
10418 MD->getParent()->isDynamicClass()) {
10419 if (!Diagnose)
10420 return false;
10421
10422 if (RD->getNumVBases()) {
10423 // Check for virtual bases. We already know that the corresponding
10424 // member in all bases is trivial, so vbases must all be direct.
10425 CXXBaseSpecifier &BS = *RD->vbases_begin();
10426 assert(BS.isVirtual());
10427 Diag(BS.getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
10428 return false;
10429 }
10430
10431 // Must have a virtual method.
10432 for (const auto *MI : RD->methods()) {
10433 if (MI->isVirtual()) {
10434 SourceLocation MLoc = MI->getBeginLoc();
10435 Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
10436 return false;
10437 }
10438 }
10439
10440 llvm_unreachable("dynamic class with no vbases and no virtual functions");
10441 }
10442
10443 // Looks like it's trivial!
10444 return true;
10445}
10446
10447namespace {
10448struct FindHiddenVirtualMethod {
10449 Sema *S;
10451 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
10452 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
10453
10454private:
10455 /// Check whether any most overridden method from MD in Methods
10456 static bool CheckMostOverridenMethods(
10457 const CXXMethodDecl *MD,
10458 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
10459 if (MD->size_overridden_methods() == 0)
10460 return Methods.count(MD->getCanonicalDecl());
10461 for (const CXXMethodDecl *O : MD->overridden_methods())
10462 if (CheckMostOverridenMethods(O, Methods))
10463 return true;
10464 return false;
10465 }
10466
10467public:
10468 /// Member lookup function that determines whether a given C++
10469 /// method overloads virtual methods in a base class without overriding any,
10470 /// to be used with CXXRecordDecl::lookupInBases().
10471 bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
10472 auto *BaseRecord = Specifier->getType()->castAsRecordDecl();
10473 DeclarationName Name = Method->getDeclName();
10474 assert(Name.getNameKind() == DeclarationName::Identifier);
10475
10476 bool foundSameNameMethod = false;
10477 SmallVector<CXXMethodDecl *, 8> overloadedMethods;
10478 for (Path.Decls = BaseRecord->lookup(Name).begin();
10479 Path.Decls != DeclContext::lookup_iterator(); ++Path.Decls) {
10480 NamedDecl *D = *Path.Decls;
10481 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
10482 MD = MD->getCanonicalDecl();
10483 foundSameNameMethod = true;
10484 // Interested only in hidden virtual methods.
10485 if (!MD->isVirtual())
10486 continue;
10487 // If the method we are checking overrides a method from its base
10488 // don't warn about the other overloaded methods. Clang deviates from
10489 // GCC by only diagnosing overloads of inherited virtual functions that
10490 // do not override any other virtual functions in the base. GCC's
10491 // -Woverloaded-virtual diagnoses any derived function hiding a virtual
10492 // function from a base class. These cases may be better served by a
10493 // warning (not specific to virtual functions) on call sites when the
10494 // call would select a different function from the base class, were it
10495 // visible.
10496 // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
10497 if (!S->IsOverload(Method, MD, false))
10498 return true;
10499 // Collect the overload only if its hidden.
10500 if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
10501 overloadedMethods.push_back(MD);
10502 }
10503 }
10504
10505 if (foundSameNameMethod)
10506 OverloadedMethods.append(overloadedMethods.begin(),
10507 overloadedMethods.end());
10508 return foundSameNameMethod;
10509 }
10510};
10511} // end anonymous namespace
10512
10513/// Add the most overridden methods from MD to Methods
10515 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
10516 if (MD->size_overridden_methods() == 0)
10517 Methods.insert(MD->getCanonicalDecl());
10518 else
10519 for (const CXXMethodDecl *O : MD->overridden_methods())
10520 AddMostOverridenMethods(O, Methods);
10521}
10522
10524 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
10525 if (!MD->getDeclName().isIdentifier())
10526 return;
10527
10528 CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
10529 /*bool RecordPaths=*/false,
10530 /*bool DetectVirtual=*/false);
10531 FindHiddenVirtualMethod FHVM;
10532 FHVM.Method = MD;
10533 FHVM.S = this;
10534
10535 // Keep the base methods that were overridden or introduced in the subclass
10536 // by 'using' in a set. A base method not in this set is hidden.
10537 CXXRecordDecl *DC = MD->getParent();
10539 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
10540 NamedDecl *ND = *I;
10541 if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
10542 ND = shad->getTargetDecl();
10543 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
10544 AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
10545 }
10546
10547 if (DC->lookupInBases(FHVM, Paths))
10548 OverloadedMethods = FHVM.OverloadedMethods;
10549}
10550
10552 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
10553 for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
10554 CXXMethodDecl *overloadedMD = OverloadedMethods[i];
10556 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
10557 HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
10558 Diag(overloadedMD->getLocation(), PD);
10559 }
10560}
10561
10563 if (MD->isInvalidDecl())
10564 return;
10565
10566 if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
10567 return;
10568
10569 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
10570 FindHiddenVirtualMethods(MD, OverloadedMethods);
10571 if (!OverloadedMethods.empty()) {
10572 Diag(MD->getLocation(), diag::warn_overloaded_virtual)
10573 << MD << (OverloadedMethods.size() > 1);
10574
10575 NoteHiddenVirtualMethods(MD, OverloadedMethods);
10576 }
10577}
10578
10580 auto PrintDiagAndRemoveAttr = [&](unsigned N) {
10581 // No diagnostics if this is a template instantiation.
10583 Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
10584 diag::ext_cannot_use_trivial_abi) << &RD;
10585 Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
10586 diag::note_cannot_use_trivial_abi_reason) << &RD << N;
10587 }
10588 RD.dropAttr<TrivialABIAttr>();
10589 };
10590
10591 // Ill-formed if the struct has virtual functions.
10592 if (RD.isPolymorphic()) {
10593 PrintDiagAndRemoveAttr(1);
10594 return;
10595 }
10596
10597 for (const auto &B : RD.bases()) {
10598 // Ill-formed if the base class is non-trivial for the purpose of calls or a
10599 // virtual base.
10600 if (!B.getType()->isDependentType() &&
10601 !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) {
10602 PrintDiagAndRemoveAttr(2);
10603 return;
10604 }
10605
10606 if (B.isVirtual()) {
10607 PrintDiagAndRemoveAttr(3);
10608 return;
10609 }
10610 }
10611
10612 for (const auto *FD : RD.fields()) {
10613 // Ill-formed if the field is an ObjectiveC pointer or of a type that is
10614 // non-trivial for the purpose of calls.
10615 QualType FT = FD->getType();
10617 PrintDiagAndRemoveAttr(4);
10618 return;
10619 }
10620
10621 // Ill-formed if the field is an address-discriminated value.
10623 PrintDiagAndRemoveAttr(6);
10624 return;
10625 }
10626
10627 if (const auto *RT =
10629 if (!RT->isDependentType() &&
10630 !cast<CXXRecordDecl>(RT->getOriginalDecl()->getDefinitionOrSelf())
10631 ->canPassInRegisters()) {
10632 PrintDiagAndRemoveAttr(5);
10633 return;
10634 }
10635 }
10636
10638 return;
10639
10640 // Ill-formed if the copy and move constructors are deleted.
10641 auto HasNonDeletedCopyOrMoveConstructor = [&]() {
10642 // If the type is dependent, then assume it might have
10643 // implicit copy or move ctor because we won't know yet at this point.
10644 if (RD.isDependentType())
10645 return true;
10648 return true;
10651 return true;
10652 for (const CXXConstructorDecl *CD : RD.ctors())
10653 if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
10654 return true;
10655 return false;
10656 };
10657
10658 if (!HasNonDeletedCopyOrMoveConstructor()) {
10659 PrintDiagAndRemoveAttr(0);
10660 return;
10661 }
10662}
10663
10665 CXXRecordDecl &RD) {
10667 diag::err_incomplete_type_vtable_pointer_auth))
10668 return;
10669
10670 const CXXRecordDecl *PrimaryBase = &RD;
10671 if (PrimaryBase->hasAnyDependentBases())
10672 return;
10673
10674 while (1) {
10675 assert(PrimaryBase);
10676 const CXXRecordDecl *Base = nullptr;
10677 for (const CXXBaseSpecifier &BasePtr : PrimaryBase->bases()) {
10678 if (!BasePtr.getType()->getAsCXXRecordDecl()->isDynamicClass())
10679 continue;
10680 Base = BasePtr.getType()->getAsCXXRecordDecl();
10681 break;
10682 }
10683 if (!Base || Base == PrimaryBase || !Base->isPolymorphic())
10684 break;
10685 Diag(RD.getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10686 diag::err_non_top_level_vtable_pointer_auth)
10687 << &RD << Base;
10688 PrimaryBase = Base;
10689 }
10690
10691 if (!RD.isPolymorphic())
10692 Diag(RD.getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10693 diag::err_non_polymorphic_vtable_pointer_auth)
10694 << &RD;
10695}
10696
10699 SourceLocation RBrac, const ParsedAttributesView &AttrList) {
10700 if (!TagDecl)
10701 return;
10702
10704
10705 for (const ParsedAttr &AL : AttrList) {
10706 if (AL.getKind() != ParsedAttr::AT_Visibility)
10707 continue;
10708 AL.setInvalid();
10709 Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
10710 }
10711
10712 ActOnFields(S, RLoc, TagDecl,
10714 // strict aliasing violation!
10715 reinterpret_cast<Decl **>(FieldCollector->getCurFields()),
10716 FieldCollector->getCurNumFields()),
10717 LBrac, RBrac, AttrList);
10718
10719 CheckCompletedCXXClass(S, cast<CXXRecordDecl>(TagDecl));
10720}
10721
10722/// Find the equality comparison functions that should be implicitly declared
10723/// in a given class definition, per C++2a [class.compare.default]p3.
10725 ASTContext &Ctx, CXXRecordDecl *RD,
10727 DeclarationName EqEq = Ctx.DeclarationNames.getCXXOperatorName(OO_EqualEqual);
10728 if (!RD->lookup(EqEq).empty())
10729 // Member operator== explicitly declared: no implicit operator==s.
10730 return;
10731
10732 // Traverse friends looking for an '==' or a '<=>'.
10733 for (FriendDecl *Friend : RD->friends()) {
10734 FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Friend->getFriendDecl());
10735 if (!FD) continue;
10736
10737 if (FD->getOverloadedOperator() == OO_EqualEqual) {
10738 // Friend operator== explicitly declared: no implicit operator==s.
10739 Spaceships.clear();
10740 return;
10741 }
10742
10743 if (FD->getOverloadedOperator() == OO_Spaceship &&
10745 Spaceships.push_back(FD);
10746 }
10747
10748 // Look for members named 'operator<=>'.
10749 DeclarationName Cmp = Ctx.DeclarationNames.getCXXOperatorName(OO_Spaceship);
10750 for (NamedDecl *ND : RD->lookup(Cmp)) {
10751 // Note that we could find a non-function here (either a function template
10752 // or a using-declaration). Neither case results in an implicit
10753 // 'operator=='.
10754 if (auto *FD = dyn_cast<FunctionDecl>(ND))
10755 if (FD->isExplicitlyDefaulted())
10756 Spaceships.push_back(FD);
10757 }
10758}
10759
10761 // Don't add implicit special members to templated classes.
10762 // FIXME: This means unqualified lookups for 'operator=' within a class
10763 // template don't work properly.
10764 if (!ClassDecl->isDependentType()) {
10765 if (ClassDecl->needsImplicitDefaultConstructor()) {
10767
10768 if (ClassDecl->hasInheritedConstructor())
10770 }
10771
10772 if (ClassDecl->needsImplicitCopyConstructor()) {
10774
10775 // If the properties or semantics of the copy constructor couldn't be
10776 // determined while the class was being declared, force a declaration
10777 // of it now.
10779 ClassDecl->hasInheritedConstructor())
10781 // For the MS ABI we need to know whether the copy ctor is deleted. A
10782 // prerequisite for deleting the implicit copy ctor is that the class has
10783 // a move ctor or move assignment that is either user-declared or whose
10784 // semantics are inherited from a subobject. FIXME: We should provide a
10785 // more direct way for CodeGen to ask whether the constructor was deleted.
10786 else if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
10787 (ClassDecl->hasUserDeclaredMoveConstructor() ||
10789 ClassDecl->hasUserDeclaredMoveAssignment() ||
10792 }
10793
10794 if (getLangOpts().CPlusPlus11 &&
10795 ClassDecl->needsImplicitMoveConstructor()) {
10797
10799 ClassDecl->hasInheritedConstructor())
10801 }
10802
10803 if (ClassDecl->needsImplicitCopyAssignment()) {
10805
10806 // If we have a dynamic class, then the copy assignment operator may be
10807 // virtual, so we have to declare it immediately. This ensures that, e.g.,
10808 // it shows up in the right place in the vtable and that we diagnose
10809 // problems with the implicit exception specification.
10810 if (ClassDecl->isDynamicClass() ||
10812 ClassDecl->hasInheritedAssignment())
10814 }
10815
10816 if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
10818
10819 // Likewise for the move assignment operator.
10820 if (ClassDecl->isDynamicClass() ||
10822 ClassDecl->hasInheritedAssignment())
10824 }
10825
10826 if (ClassDecl->needsImplicitDestructor()) {
10828
10829 // If we have a dynamic class, then the destructor may be virtual, so we
10830 // have to declare the destructor immediately. This ensures that, e.g., it
10831 // shows up in the right place in the vtable and that we diagnose problems
10832 // with the implicit exception specification.
10833 if (ClassDecl->isDynamicClass() ||
10835 DeclareImplicitDestructor(ClassDecl);
10836 }
10837 }
10838
10839 // C++2a [class.compare.default]p3:
10840 // If the member-specification does not explicitly declare any member or
10841 // friend named operator==, an == operator function is declared implicitly
10842 // for each defaulted three-way comparison operator function defined in
10843 // the member-specification
10844 // FIXME: Consider doing this lazily.
10845 // We do this during the initial parse for a class template, not during
10846 // instantiation, so that we can handle unqualified lookups for 'operator=='
10847 // when parsing the template.
10849 llvm::SmallVector<FunctionDecl *, 4> DefaultedSpaceships;
10851 DefaultedSpaceships);
10852 for (auto *FD : DefaultedSpaceships)
10853 DeclareImplicitEqualityComparison(ClassDecl, FD);
10854 }
10855}
10856
10857unsigned
10859 llvm::function_ref<Scope *()> EnterScope) {
10860 if (!D)
10861 return 0;
10863
10864 // In order to get name lookup right, reenter template scopes in order from
10865 // outermost to innermost.
10867 DeclContext *LookupDC = dyn_cast<DeclContext>(D);
10868
10869 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
10870 for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
10871 ParameterLists.push_back(DD->getTemplateParameterList(i));
10872
10873 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
10874 if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
10875 ParameterLists.push_back(FTD->getTemplateParameters());
10876 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
10877 LookupDC = VD->getDeclContext();
10878
10880 ParameterLists.push_back(VTD->getTemplateParameters());
10881 else if (auto *PSD = dyn_cast<VarTemplatePartialSpecializationDecl>(D))
10882 ParameterLists.push_back(PSD->getTemplateParameters());
10883 }
10884 } else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
10885 for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
10886 ParameterLists.push_back(TD->getTemplateParameterList(i));
10887
10888 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
10890 ParameterLists.push_back(CTD->getTemplateParameters());
10891 else if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
10892 ParameterLists.push_back(PSD->getTemplateParameters());
10893 }
10894 }
10895 // FIXME: Alias declarations and concepts.
10896
10897 unsigned Count = 0;
10898 Scope *InnermostTemplateScope = nullptr;
10899 for (TemplateParameterList *Params : ParameterLists) {
10900 // Ignore explicit specializations; they don't contribute to the template
10901 // depth.
10902 if (Params->size() == 0)
10903 continue;
10904
10905 InnermostTemplateScope = EnterScope();
10906 for (NamedDecl *Param : *Params) {
10907 if (Param->getDeclName()) {
10908 InnermostTemplateScope->AddDecl(Param);
10909 IdResolver.AddDecl(Param);
10910 }
10911 }
10912 ++Count;
10913 }
10914
10915 // Associate the new template scopes with the corresponding entities.
10916 if (InnermostTemplateScope) {
10917 assert(LookupDC && "no enclosing DeclContext for template lookup");
10918 EnterTemplatedContext(InnermostTemplateScope, LookupDC);
10919 }
10920
10921 return Count;
10922}
10923
10925 if (!RecordD) return;
10926 AdjustDeclIfTemplate(RecordD);
10927 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
10929}
10930
10932 if (!RecordD) return;
10934}
10935
10937 if (!Param)
10938 return;
10939
10940 S->AddDecl(Param);
10941 if (Param->getDeclName())
10942 IdResolver.AddDecl(Param);
10943}
10944
10946}
10947
10948/// ActOnDelayedCXXMethodParameter - We've already started a delayed
10949/// C++ method declaration. We're (re-)introducing the given
10950/// function parameter into scope for use in parsing later parts of
10951/// the method declaration. For example, we could see an
10952/// ActOnParamDefaultArgument event for this parameter.
10954 if (!ParamD)
10955 return;
10956
10957 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
10958
10959 S->AddDecl(Param);
10960 if (Param->getDeclName())
10961 IdResolver.AddDecl(Param);
10962}
10963
10965 if (!MethodD)
10966 return;
10967
10968 AdjustDeclIfTemplate(MethodD);
10969
10970 FunctionDecl *Method = cast<FunctionDecl>(MethodD);
10971
10972 // Now that we have our default arguments, check the constructor
10973 // again. It could produce additional diagnostics or affect whether
10974 // the class has implicitly-declared destructors, among other
10975 // things.
10976 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
10978
10979 // Check the default arguments, which we may have added.
10980 if (!Method->isInvalidDecl())
10982}
10983
10984// Emit the given diagnostic for each non-address-space qualifier.
10985// Common part of CheckConstructorDeclarator and CheckDestructorDeclarator.
10986static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID) {
10987 const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
10988 if (FTI.hasMethodTypeQualifiers() && !D.isInvalidType()) {
10989 bool DiagOccured = false;
10991 [DiagID, &S, &DiagOccured](DeclSpec::TQ, StringRef QualName,
10992 SourceLocation SL) {
10993 // This diagnostic should be emitted on any qualifier except an addr
10994 // space qualifier. However, forEachQualifier currently doesn't visit
10995 // addr space qualifiers, so there's no way to write this condition
10996 // right now; we just diagnose on everything.
10997 S.Diag(SL, DiagID) << QualName << SourceRange(SL);
10998 DiagOccured = true;
10999 });
11000 if (DiagOccured)
11001 D.setInvalidType();
11002 }
11003}
11004
11006 unsigned Kind) {
11007 if (D.isInvalidType() || D.getNumTypeObjects() <= 1)
11008 return;
11009
11010 DeclaratorChunk &Chunk = D.getTypeObject(D.getNumTypeObjects() - 1);
11011 if (Chunk.Kind == DeclaratorChunk::Paren ||
11013 return;
11014
11015 SourceLocation PointerLoc = Chunk.getSourceRange().getBegin();
11016 S.Diag(PointerLoc, diag::err_invalid_ctor_dtor_decl)
11017 << Kind << Chunk.getSourceRange();
11018 D.setInvalidType();
11019}
11020
11022 StorageClass &SC) {
11023 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
11024
11025 // C++ [class.ctor]p3:
11026 // A constructor shall not be virtual (10.3) or static (9.4). A
11027 // constructor can be invoked for a const, volatile or const
11028 // volatile object. A constructor shall not be declared const,
11029 // volatile, or const volatile (9.3.2).
11030 if (isVirtual) {
11031 if (!D.isInvalidType())
11032 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
11033 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
11034 << SourceRange(D.getIdentifierLoc());
11035 D.setInvalidType();
11036 }
11037 if (SC == SC_Static) {
11038 if (!D.isInvalidType())
11039 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
11040 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
11041 << SourceRange(D.getIdentifierLoc());
11042 D.setInvalidType();
11043 SC = SC_None;
11044 }
11045
11046 if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
11048 diag::err_constructor_return_type, TypeQuals, SourceLocation(),
11049 D.getDeclSpec().getConstSpecLoc(), D.getDeclSpec().getVolatileSpecLoc(),
11050 D.getDeclSpec().getRestrictSpecLoc(),
11051 D.getDeclSpec().getAtomicSpecLoc());
11052 D.setInvalidType();
11053 }
11054
11055 checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_constructor);
11056 diagnoseInvalidDeclaratorChunks(*this, D, /*constructor*/ 0);
11057
11058 // C++0x [class.ctor]p4:
11059 // A constructor shall not be declared with a ref-qualifier.
11060 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11061 if (FTI.hasRefQualifier()) {
11062 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
11065 D.setInvalidType();
11066 }
11067
11068 // Rebuild the function type "R" without any type qualifiers (in
11069 // case any of the errors above fired) and with "void" as the
11070 // return type, since constructors don't have return types.
11071 const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
11072 if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
11073 return R;
11074
11076 EPI.TypeQuals = Qualifiers();
11077 EPI.RefQualifier = RQ_None;
11078
11079 return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
11080}
11081
11083 CXXRecordDecl *ClassDecl
11084 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
11085 if (!ClassDecl)
11086 return Constructor->setInvalidDecl();
11087
11088 // C++ [class.copy]p3:
11089 // A declaration of a constructor for a class X is ill-formed if
11090 // its first parameter is of type (optionally cv-qualified) X and
11091 // either there are no other parameters or else all other
11092 // parameters have default arguments.
11093 if (!Constructor->isInvalidDecl() &&
11094 Constructor->hasOneParamOrDefaultArgs() &&
11095 !Constructor->isFunctionTemplateSpecialization()) {
11096 CanQualType ParamType =
11097 Constructor->getParamDecl(0)->getType()->getCanonicalTypeUnqualified();
11098 CanQualType ClassTy = Context.getCanonicalTagType(ClassDecl);
11099 if (ParamType == ClassTy) {
11100 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
11101 const char *ConstRef
11102 = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
11103 : " const &";
11104 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
11105 << FixItHint::CreateInsertion(ParamLoc, ConstRef);
11106
11107 // FIXME: Rather that making the constructor invalid, we should endeavor
11108 // to fix the type.
11109 Constructor->setInvalidDecl();
11110 }
11111 }
11112}
11113
11115 CXXRecordDecl *RD = Destructor->getParent();
11116
11117 if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
11119
11120 if (!Destructor->isImplicit())
11121 Loc = Destructor->getLocation();
11122 else
11123 Loc = RD->getLocation();
11124
11125 // If we have a virtual destructor, look up the deallocation function
11126 if (FunctionDecl *OperatorDelete =
11128 Expr *ThisArg = nullptr;
11129
11130 // If the notional 'delete this' expression requires a non-trivial
11131 // conversion from 'this' to the type of a destroying operator delete's
11132 // first parameter, perform that conversion now.
11133 if (OperatorDelete->isDestroyingOperatorDelete()) {
11134 unsigned AddressParamIndex = 0;
11135 if (OperatorDelete->isTypeAwareOperatorNewOrDelete())
11136 ++AddressParamIndex;
11137 QualType ParamType =
11138 OperatorDelete->getParamDecl(AddressParamIndex)->getType();
11139 if (!declaresSameEntity(ParamType->getAsCXXRecordDecl(), RD)) {
11140 // C++ [class.dtor]p13:
11141 // ... as if for the expression 'delete this' appearing in a
11142 // non-virtual destructor of the destructor's class.
11143 ContextRAII SwitchContext(*this, Destructor);
11145 OperatorDelete->getParamDecl(AddressParamIndex)->getLocation());
11146 assert(!This.isInvalid() && "couldn't form 'this' expr in dtor?");
11147 This = PerformImplicitConversion(This.get(), ParamType,
11149 if (This.isInvalid()) {
11150 // FIXME: Register this as a context note so that it comes out
11151 // in the right order.
11152 Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
11153 return true;
11154 }
11155 ThisArg = This.get();
11156 }
11157 }
11158
11159 DiagnoseUseOfDecl(OperatorDelete, Loc);
11160 MarkFunctionReferenced(Loc, OperatorDelete);
11161 Destructor->setOperatorDelete(OperatorDelete, ThisArg);
11162 }
11163 }
11164
11165 return false;
11166}
11167
11169 StorageClass& SC) {
11170 // C++ [class.dtor]p1:
11171 // [...] A typedef-name that names a class is a class-name
11172 // (7.1.3); however, a typedef-name that names a class shall not
11173 // be used as the identifier in the declarator for a destructor
11174 // declaration.
11175 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
11176 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
11177 Diag(D.getIdentifierLoc(), diag::ext_destructor_typedef_name)
11178 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
11179 else if (const TemplateSpecializationType *TST =
11180 DeclaratorType->getAs<TemplateSpecializationType>())
11181 if (TST->isTypeAlias())
11182 Diag(D.getIdentifierLoc(), diag::ext_destructor_typedef_name)
11183 << DeclaratorType << 1;
11184
11185 // C++ [class.dtor]p2:
11186 // A destructor is used to destroy objects of its class type. A
11187 // destructor takes no parameters, and no return type can be
11188 // specified for it (not even void). The address of a destructor
11189 // shall not be taken. A destructor shall not be static. A
11190 // destructor can be invoked for a const, volatile or const
11191 // volatile object. A destructor shall not be declared const,
11192 // volatile or const volatile (9.3.2).
11193 if (SC == SC_Static) {
11194 if (!D.isInvalidType())
11195 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
11196 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
11197 << SourceRange(D.getIdentifierLoc())
11198 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
11199
11200 SC = SC_None;
11201 }
11202 if (!D.isInvalidType()) {
11203 // Destructors don't have return types, but the parser will
11204 // happily parse something like:
11205 //
11206 // class X {
11207 // float ~X();
11208 // };
11209 //
11210 // The return type will be eliminated later.
11211 if (D.getDeclSpec().hasTypeSpecifier())
11212 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
11213 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
11214 << SourceRange(D.getIdentifierLoc());
11215 else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
11216 diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
11218 D.getDeclSpec().getConstSpecLoc(),
11219 D.getDeclSpec().getVolatileSpecLoc(),
11220 D.getDeclSpec().getRestrictSpecLoc(),
11221 D.getDeclSpec().getAtomicSpecLoc());
11222 D.setInvalidType();
11223 }
11224 }
11225
11226 checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_destructor);
11227 diagnoseInvalidDeclaratorChunks(*this, D, /*destructor*/ 1);
11228
11229 // C++0x [class.dtor]p2:
11230 // A destructor shall not be declared with a ref-qualifier.
11231 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11232 if (FTI.hasRefQualifier()) {
11233 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
11236 D.setInvalidType();
11237 }
11238
11239 // Make sure we don't have any parameters.
11240 if (FTIHasNonVoidParameters(FTI)) {
11241 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
11242
11243 // Delete the parameters.
11244 FTI.freeParams();
11245 D.setInvalidType();
11246 }
11247
11248 // Make sure the destructor isn't variadic.
11249 if (FTI.isVariadic) {
11250 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
11251 D.setInvalidType();
11252 }
11253
11254 // Rebuild the function type "R" without any type qualifiers or
11255 // parameters (in case any of the errors above fired) and with
11256 // "void" as the return type, since destructors don't have return
11257 // types.
11258 if (!D.isInvalidType())
11259 return R;
11260
11261 const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
11263 EPI.Variadic = false;
11264 EPI.TypeQuals = Qualifiers();
11265 EPI.RefQualifier = RQ_None;
11266 return Context.getFunctionType(Context.VoidTy, {}, EPI);
11267}
11268
11269static void extendLeft(SourceRange &R, SourceRange Before) {
11270 if (Before.isInvalid())
11271 return;
11272 R.setBegin(Before.getBegin());
11273 if (R.getEnd().isInvalid())
11274 R.setEnd(Before.getEnd());
11275}
11276
11277static void extendRight(SourceRange &R, SourceRange After) {
11278 if (After.isInvalid())
11279 return;
11280 if (R.getBegin().isInvalid())
11281 R.setBegin(After.getBegin());
11282 R.setEnd(After.getEnd());
11283}
11284
11286 StorageClass& SC) {
11287 // C++ [class.conv.fct]p1:
11288 // Neither parameter types nor return type can be specified. The
11289 // type of a conversion function (8.3.5) is "function taking no
11290 // parameter returning conversion-type-id."
11291 if (SC == SC_Static) {
11292 if (!D.isInvalidType())
11293 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
11294 << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
11295 << D.getName().getSourceRange();
11296 D.setInvalidType();
11297 SC = SC_None;
11298 }
11299
11300 TypeSourceInfo *ConvTSI = nullptr;
11301 QualType ConvType =
11302 GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);
11303
11304 const DeclSpec &DS = D.getDeclSpec();
11305 if (DS.hasTypeSpecifier() && !D.isInvalidType()) {
11306 // Conversion functions don't have return types, but the parser will
11307 // happily parse something like:
11308 //
11309 // class X {
11310 // float operator bool();
11311 // };
11312 //
11313 // The return type will be changed later anyway.
11314 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
11316 << SourceRange(D.getIdentifierLoc());
11317 D.setInvalidType();
11318 } else if (DS.getTypeQualifiers() && !D.isInvalidType()) {
11319 // It's also plausible that the user writes type qualifiers in the wrong
11320 // place, such as:
11321 // struct S { const operator int(); };
11322 // FIXME: we could provide a fixit to move the qualifiers onto the
11323 // conversion type.
11324 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
11325 << SourceRange(D.getIdentifierLoc()) << 0;
11326 D.setInvalidType();
11327 }
11328 const auto *Proto = R->castAs<FunctionProtoType>();
11329 // Make sure we don't have any parameters.
11330 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11331 unsigned NumParam = Proto->getNumParams();
11332
11333 // [C++2b]
11334 // A conversion function shall have no non-object parameters.
11335 if (NumParam == 1) {
11336 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11337 if (const auto *First =
11338 dyn_cast_if_present<ParmVarDecl>(FTI.Params[0].Param);
11339 First && First->isExplicitObjectParameter())
11340 NumParam--;
11341 }
11342
11343 if (NumParam != 0) {
11344 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
11345 // Delete the parameters.
11346 FTI.freeParams();
11347 D.setInvalidType();
11348 } else if (Proto->isVariadic()) {
11349 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
11350 D.setInvalidType();
11351 }
11352
11353 // Diagnose "&operator bool()" and other such nonsense. This
11354 // is actually a gcc extension which we don't support.
11355 if (Proto->getReturnType() != ConvType) {
11356 bool NeedsTypedef = false;
11357 SourceRange Before, After;
11358
11359 // Walk the chunks and extract information on them for our diagnostic.
11360 bool PastFunctionChunk = false;
11361 for (auto &Chunk : D.type_objects()) {
11362 switch (Chunk.Kind) {
11364 if (!PastFunctionChunk) {
11365 if (Chunk.Fun.HasTrailingReturnType) {
11366 TypeSourceInfo *TRT = nullptr;
11367 GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
11368 if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
11369 }
11370 PastFunctionChunk = true;
11371 break;
11372 }
11373 [[fallthrough]];
11375 NeedsTypedef = true;
11376 extendRight(After, Chunk.getSourceRange());
11377 break;
11378
11384 extendLeft(Before, Chunk.getSourceRange());
11385 break;
11386
11388 extendLeft(Before, Chunk.Loc);
11389 extendRight(After, Chunk.EndLoc);
11390 break;
11391 }
11392 }
11393
11394 SourceLocation Loc = Before.isValid() ? Before.getBegin() :
11395 After.isValid() ? After.getBegin() :
11396 D.getIdentifierLoc();
11397 auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
11398 DB << Before << After;
11399
11400 if (!NeedsTypedef) {
11401 DB << /*don't need a typedef*/0;
11402
11403 // If we can provide a correct fix-it hint, do so.
11404 if (After.isInvalid() && ConvTSI) {
11405 SourceLocation InsertLoc =
11407 DB << FixItHint::CreateInsertion(InsertLoc, " ")
11409 InsertLoc, CharSourceRange::getTokenRange(Before))
11410 << FixItHint::CreateRemoval(Before);
11411 }
11412 } else if (!Proto->getReturnType()->isDependentType()) {
11413 DB << /*typedef*/1 << Proto->getReturnType();
11414 } else if (getLangOpts().CPlusPlus11) {
11415 DB << /*alias template*/2 << Proto->getReturnType();
11416 } else {
11417 DB << /*might not be fixable*/3;
11418 }
11419
11420 // Recover by incorporating the other type chunks into the result type.
11421 // Note, this does *not* change the name of the function. This is compatible
11422 // with the GCC extension:
11423 // struct S { &operator int(); } s;
11424 // int &r = s.operator int(); // ok in GCC
11425 // S::operator int&() {} // error in GCC, function name is 'operator int'.
11426 ConvType = Proto->getReturnType();
11427 }
11428
11429 // C++ [class.conv.fct]p4:
11430 // The conversion-type-id shall not represent a function type nor
11431 // an array type.
11432 if (ConvType->isArrayType()) {
11433 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
11434 ConvType = Context.getPointerType(ConvType);
11435 D.setInvalidType();
11436 } else if (ConvType->isFunctionType()) {
11437 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
11438 ConvType = Context.getPointerType(ConvType);
11439 D.setInvalidType();
11440 }
11441
11442 // Rebuild the function type "R" without any parameters (in case any
11443 // of the errors above fired) and with the conversion type as the
11444 // return type.
11445 if (D.isInvalidType())
11446 R = Context.getFunctionType(ConvType, {}, Proto->getExtProtoInfo());
11447
11448 // C++0x explicit conversion operators.
11452 ? diag::warn_cxx98_compat_explicit_conversion_functions
11453 : diag::ext_explicit_conversion_functions)
11455}
11456
11458 assert(Conversion && "Expected to receive a conversion function declaration");
11459
11460 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
11461
11462 // Make sure we aren't redeclaring the conversion function.
11463 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
11464 // C++ [class.conv.fct]p1:
11465 // [...] A conversion function is never used to convert a
11466 // (possibly cv-qualified) object to the (possibly cv-qualified)
11467 // same object type (or a reference to it), to a (possibly
11468 // cv-qualified) base class of that type (or a reference to it),
11469 // or to (possibly cv-qualified) void.
11470 CanQualType ClassType = Context.getCanonicalTagType(ClassDecl);
11471 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
11472 ConvType = ConvTypeRef->getPointeeType();
11473 if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
11475 /* Suppress diagnostics for instantiations. */;
11476 else if (Conversion->size_overridden_methods() != 0)
11477 /* Suppress diagnostics for overriding virtual function in a base class. */;
11478 else if (ConvType->isRecordType()) {
11479 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
11480 if (ConvType == ClassType)
11481 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
11482 << ClassType;
11483 else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
11484 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
11485 << ClassType << ConvType;
11486 } else if (ConvType->isVoidType()) {
11487 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
11488 << ClassType << ConvType;
11489 }
11490
11491 if (FunctionTemplateDecl *ConversionTemplate =
11492 Conversion->getDescribedFunctionTemplate()) {
11493 if (const auto *ConvTypePtr = ConvType->getAs<PointerType>()) {
11494 ConvType = ConvTypePtr->getPointeeType();
11495 }
11496 if (ConvType->isUndeducedAutoType()) {
11497 Diag(Conversion->getTypeSpecStartLoc(), diag::err_auto_not_allowed)
11498 << getReturnTypeLoc(Conversion).getSourceRange()
11499 << ConvType->castAs<AutoType>()->getKeyword()
11500 << /* in declaration of conversion function template= */ 24;
11501 }
11502
11503 return ConversionTemplate;
11504 }
11505
11506 return Conversion;
11507}
11508
11510 DeclarationName Name, QualType R) {
11511 CheckExplicitObjectMemberFunction(D, Name, R, false, DC);
11512}
11513
11515 CheckExplicitObjectMemberFunction(D, {}, {}, true);
11516}
11517
11519 DeclarationName Name, QualType R,
11520 bool IsLambda, DeclContext *DC) {
11521 if (!D.isFunctionDeclarator())
11522 return;
11523
11524 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11525 if (FTI.NumParams == 0)
11526 return;
11527 ParmVarDecl *ExplicitObjectParam = nullptr;
11528 for (unsigned Idx = 0; Idx < FTI.NumParams; Idx++) {
11529 const auto &ParamInfo = FTI.Params[Idx];
11530 if (!ParamInfo.Param)
11531 continue;
11532 ParmVarDecl *Param = cast<ParmVarDecl>(ParamInfo.Param);
11533 if (!Param->isExplicitObjectParameter())
11534 continue;
11535 if (Idx == 0) {
11536 ExplicitObjectParam = Param;
11537 continue;
11538 } else {
11539 Diag(Param->getLocation(),
11540 diag::err_explicit_object_parameter_must_be_first)
11541 << IsLambda << Param->getSourceRange();
11542 }
11543 }
11544 if (!ExplicitObjectParam)
11545 return;
11546
11547 if (ExplicitObjectParam->hasDefaultArg()) {
11548 Diag(ExplicitObjectParam->getLocation(),
11549 diag::err_explicit_object_default_arg)
11550 << ExplicitObjectParam->getSourceRange();
11551 }
11552
11553 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
11554 (D.getContext() == clang::DeclaratorContext::Member &&
11555 D.isStaticMember())) {
11556 Diag(ExplicitObjectParam->getBeginLoc(),
11557 diag::err_explicit_object_parameter_nonmember)
11558 << D.getSourceRange() << /*static=*/0 << IsLambda;
11559 D.setInvalidType();
11560 }
11561
11562 if (D.getDeclSpec().isVirtualSpecified()) {
11563 Diag(ExplicitObjectParam->getBeginLoc(),
11564 diag::err_explicit_object_parameter_nonmember)
11565 << D.getSourceRange() << /*virtual=*/1 << IsLambda;
11566 D.setInvalidType();
11567 }
11568
11569 // Friend declarations require some care. Consider:
11570 //
11571 // namespace N {
11572 // struct A{};
11573 // int f(A);
11574 // }
11575 //
11576 // struct S {
11577 // struct T {
11578 // int f(this T);
11579 // };
11580 //
11581 // friend int T::f(this T); // Allow this.
11582 // friend int f(this S); // But disallow this.
11583 // friend int N::f(this A); // And disallow this.
11584 // };
11585 //
11586 // Here, it seems to suffice to check whether the scope
11587 // specifier designates a class type.
11588 if (D.getDeclSpec().isFriendSpecified() &&
11589 !isa_and_present<CXXRecordDecl>(
11590 computeDeclContext(D.getCXXScopeSpec()))) {
11591 Diag(ExplicitObjectParam->getBeginLoc(),
11592 diag::err_explicit_object_parameter_nonmember)
11593 << D.getSourceRange() << /*non-member=*/2 << IsLambda;
11594 D.setInvalidType();
11595 }
11596
11597 if (IsLambda && FTI.hasMutableQualifier()) {
11598 Diag(ExplicitObjectParam->getBeginLoc(),
11599 diag::err_explicit_object_parameter_mutable)
11600 << D.getSourceRange();
11601 }
11602
11603 if (IsLambda)
11604 return;
11605
11606 if (!DC || !DC->isRecord()) {
11607 assert(D.isInvalidType() && "Explicit object parameter in non-member "
11608 "should have been diagnosed already");
11609 return;
11610 }
11611
11612 // CWG2674: constructors and destructors cannot have explicit parameters.
11613 if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
11614 Name.getNameKind() == DeclarationName::CXXDestructorName) {
11615 Diag(ExplicitObjectParam->getBeginLoc(),
11616 diag::err_explicit_object_parameter_constructor)
11617 << (Name.getNameKind() == DeclarationName::CXXDestructorName)
11618 << D.getSourceRange();
11619 D.setInvalidType();
11620 }
11621}
11622
11623namespace {
11624/// Utility class to accumulate and print a diagnostic listing the invalid
11625/// specifier(s) on a declaration.
11626struct BadSpecifierDiagnoser {
11627 BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
11628 : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
11629 ~BadSpecifierDiagnoser() {
11630 Diagnostic << Specifiers;
11631 }
11632
11633 template<typename T> void check(SourceLocation SpecLoc, T Spec) {
11634 return check(SpecLoc, DeclSpec::getSpecifierName(Spec));
11635 }
11636 void check(SourceLocation SpecLoc, DeclSpec::TST Spec) {
11637 return check(SpecLoc,
11639 }
11640 void check(SourceLocation SpecLoc, const char *Spec) {
11641 if (SpecLoc.isInvalid()) return;
11642 Diagnostic << SourceRange(SpecLoc, SpecLoc);
11643 if (!Specifiers.empty()) Specifiers += " ";
11644 Specifiers += Spec;
11645 }
11646
11647 Sema &S;
11649 std::string Specifiers;
11650};
11651}
11652
11654 StorageClass &SC) {
11655 TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
11656 TemplateDecl *GuidedTemplateDecl = GuidedTemplate.getAsTemplateDecl();
11657 assert(GuidedTemplateDecl && "missing template decl for deduction guide");
11658
11659 // C++ [temp.deduct.guide]p3:
11660 // A deduction-gide shall be declared in the same scope as the
11661 // corresponding class template.
11663 GuidedTemplateDecl->getDeclContext()->getRedeclContext())) {
11664 Diag(D.getIdentifierLoc(), diag::err_deduction_guide_wrong_scope)
11665 << GuidedTemplateDecl;
11666 NoteTemplateLocation(*GuidedTemplateDecl);
11667 }
11668
11669 auto &DS = D.getMutableDeclSpec();
11670 // We leave 'friend' and 'virtual' to be rejected in the normal way.
11671 if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
11672 DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
11673 DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
11674 BadSpecifierDiagnoser Diagnoser(
11675 *this, D.getIdentifierLoc(),
11676 diag::err_deduction_guide_invalid_specifier);
11677
11678 Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
11679 DS.ClearStorageClassSpecs();
11680 SC = SC_None;
11681
11682 // 'explicit' is permitted.
11683 Diagnoser.check(DS.getInlineSpecLoc(), "inline");
11684 Diagnoser.check(DS.getNoreturnSpecLoc(), "_Noreturn");
11685 Diagnoser.check(DS.getConstexprSpecLoc(), "constexpr");
11686 DS.ClearConstexprSpec();
11687
11688 Diagnoser.check(DS.getConstSpecLoc(), "const");
11689 Diagnoser.check(DS.getRestrictSpecLoc(), "__restrict");
11690 Diagnoser.check(DS.getVolatileSpecLoc(), "volatile");
11691 Diagnoser.check(DS.getAtomicSpecLoc(), "_Atomic");
11692 Diagnoser.check(DS.getUnalignedSpecLoc(), "__unaligned");
11693 DS.ClearTypeQualifiers();
11694
11695 Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
11696 Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
11697 Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
11698 Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
11699 DS.ClearTypeSpecType();
11700 }
11701
11702 if (D.isInvalidType())
11703 return true;
11704
11705 // Check the declarator is simple enough.
11706 bool FoundFunction = false;
11707 for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
11708 if (Chunk.Kind == DeclaratorChunk::Paren)
11709 continue;
11710 if (Chunk.Kind != DeclaratorChunk::Function || FoundFunction) {
11711 Diag(D.getDeclSpec().getBeginLoc(),
11712 diag::err_deduction_guide_with_complex_decl)
11713 << D.getSourceRange();
11714 break;
11715 }
11716 if (!Chunk.Fun.hasTrailingReturnType())
11717 return Diag(D.getName().getBeginLoc(),
11718 diag::err_deduction_guide_no_trailing_return_type);
11719
11720 // Check that the return type is written as a specialization of
11721 // the template specified as the deduction-guide's name.
11722 // The template name may not be qualified. [temp.deduct.guide]
11723 ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
11724 TypeSourceInfo *TSI = nullptr;
11725 QualType RetTy = GetTypeFromParser(TrailingReturnType, &TSI);
11726 assert(TSI && "deduction guide has valid type but invalid return type?");
11727 bool AcceptableReturnType = false;
11728 bool MightInstantiateToSpecialization = false;
11729 if (auto RetTST =
11731 TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
11732 bool TemplateMatches = Context.hasSameTemplateName(
11733 SpecifiedName, GuidedTemplate, /*IgnoreDeduced=*/true);
11734
11736 SpecifiedName.getAsQualifiedTemplateName();
11737 assert(Qualifiers && "expected QualifiedTemplate");
11738 bool SimplyWritten =
11739 !Qualifiers->hasTemplateKeyword() && !Qualifiers->getQualifier();
11740 if (SimplyWritten && TemplateMatches)
11741 AcceptableReturnType = true;
11742 else {
11743 // This could still instantiate to the right type, unless we know it
11744 // names the wrong class template.
11745 auto *TD = SpecifiedName.getAsTemplateDecl();
11746 MightInstantiateToSpecialization =
11747 !(TD && isa<ClassTemplateDecl>(TD) && !TemplateMatches);
11748 }
11749 } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
11750 MightInstantiateToSpecialization = true;
11751 }
11752
11753 if (!AcceptableReturnType)
11754 return Diag(TSI->getTypeLoc().getBeginLoc(),
11755 diag::err_deduction_guide_bad_trailing_return_type)
11756 << GuidedTemplate << TSI->getType()
11757 << MightInstantiateToSpecialization
11758 << TSI->getTypeLoc().getSourceRange();
11759
11760 // Keep going to check that we don't have any inner declarator pieces (we
11761 // could still have a function returning a pointer to a function).
11762 FoundFunction = true;
11763 }
11764
11765 if (D.isFunctionDefinition())
11766 // we can still create a valid deduction guide here.
11767 Diag(D.getIdentifierLoc(), diag::err_deduction_guide_defines_function);
11768 return false;
11769}
11770
11771//===----------------------------------------------------------------------===//
11772// Namespace Handling
11773//===----------------------------------------------------------------------===//
11774
11775/// Diagnose a mismatch in 'inline' qualifiers when a namespace is
11776/// reopened.
11779 IdentifierInfo *II, bool *IsInline,
11780 NamespaceDecl *PrevNS) {
11781 assert(*IsInline != PrevNS->isInline());
11782
11783 // 'inline' must appear on the original definition, but not necessarily
11784 // on all extension definitions, so the note should point to the first
11785 // definition to avoid confusion.
11786 PrevNS = PrevNS->getFirstDecl();
11787
11788 if (PrevNS->isInline())
11789 // The user probably just forgot the 'inline', so suggest that it
11790 // be added back.
11791 S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
11792 << FixItHint::CreateInsertion(KeywordLoc, "inline ");
11793 else
11794 S.Diag(Loc, diag::err_inline_namespace_mismatch);
11795
11796 S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
11797 *IsInline = PrevNS->isInline();
11798}
11799
11800/// ActOnStartNamespaceDef - This is called at the start of a namespace
11801/// definition.
11803 SourceLocation InlineLoc,
11804 SourceLocation NamespaceLoc,
11805 SourceLocation IdentLoc, IdentifierInfo *II,
11806 SourceLocation LBrace,
11807 const ParsedAttributesView &AttrList,
11808 UsingDirectiveDecl *&UD, bool IsNested) {
11809 SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
11810 // For anonymous namespace, take the location of the left brace.
11811 SourceLocation Loc = II ? IdentLoc : LBrace;
11812 bool IsInline = InlineLoc.isValid();
11813 bool IsInvalid = false;
11814 bool IsStd = false;
11815 bool AddToKnown = false;
11816 Scope *DeclRegionScope = NamespcScope->getParent();
11817
11818 NamespaceDecl *PrevNS = nullptr;
11819 if (II) {
11820 // C++ [namespace.std]p7:
11821 // A translation unit shall not declare namespace std to be an inline
11822 // namespace (9.8.2).
11823 //
11824 // Precondition: the std namespace is in the file scope and is declared to
11825 // be inline
11826 auto DiagnoseInlineStdNS = [&]() {
11827 assert(IsInline && II->isStr("std") &&
11829 "Precondition of DiagnoseInlineStdNS not met");
11830 Diag(InlineLoc, diag::err_inline_namespace_std)
11831 << SourceRange(InlineLoc, InlineLoc.getLocWithOffset(6));
11832 IsInline = false;
11833 };
11834 // C++ [namespace.def]p2:
11835 // The identifier in an original-namespace-definition shall not
11836 // have been previously defined in the declarative region in
11837 // which the original-namespace-definition appears. The
11838 // identifier in an original-namespace-definition is the name of
11839 // the namespace. Subsequently in that declarative region, it is
11840 // treated as an original-namespace-name.
11841 //
11842 // Since namespace names are unique in their scope, and we don't
11843 // look through using directives, just look for any ordinary names
11844 // as if by qualified name lookup.
11845 LookupResult R(*this, II, IdentLoc, LookupOrdinaryName,
11846 RedeclarationKind::ForExternalRedeclaration);
11848 NamedDecl *PrevDecl =
11849 R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
11850 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
11851
11852 if (PrevNS) {
11853 // This is an extended namespace definition.
11854 if (IsInline && II->isStr("std") &&
11856 DiagnoseInlineStdNS();
11857 else if (IsInline != PrevNS->isInline())
11858 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
11859 &IsInline, PrevNS);
11860 } else if (PrevDecl) {
11861 // This is an invalid name redefinition.
11862 Diag(Loc, diag::err_redefinition_different_kind)
11863 << II;
11864 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
11865 IsInvalid = true;
11866 // Continue on to push Namespc as current DeclContext and return it.
11867 } else if (II->isStr("std") &&
11869 if (IsInline)
11870 DiagnoseInlineStdNS();
11871 // This is the first "real" definition of the namespace "std", so update
11872 // our cache of the "std" namespace to point at this definition.
11873 PrevNS = getStdNamespace();
11874 IsStd = true;
11875 AddToKnown = !IsInline;
11876 } else {
11877 // We've seen this namespace for the first time.
11878 AddToKnown = !IsInline;
11879 }
11880 } else {
11881 // Anonymous namespaces.
11882
11883 // Determine whether the parent already has an anonymous namespace.
11885 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
11886 PrevNS = TU->getAnonymousNamespace();
11887 } else {
11888 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
11889 PrevNS = ND->getAnonymousNamespace();
11890 }
11891
11892 if (PrevNS && IsInline != PrevNS->isInline())
11893 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
11894 &IsInline, PrevNS);
11895 }
11896
11898 Context, CurContext, IsInline, StartLoc, Loc, II, PrevNS, IsNested);
11899 if (IsInvalid)
11900 Namespc->setInvalidDecl();
11901
11902 ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
11903 AddPragmaAttributes(DeclRegionScope, Namespc);
11904 ProcessAPINotes(Namespc);
11905
11906 // FIXME: Should we be merging attributes?
11907 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
11909
11910 if (IsStd)
11911 StdNamespace = Namespc;
11912 if (AddToKnown)
11913 KnownNamespaces[Namespc] = false;
11914
11915 if (II) {
11916 PushOnScopeChains(Namespc, DeclRegionScope);
11917 } else {
11918 // Link the anonymous namespace into its parent.
11920 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
11921 TU->setAnonymousNamespace(Namespc);
11922 } else {
11923 cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
11924 }
11925
11926 CurContext->addDecl(Namespc);
11927
11928 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
11929 // behaves as if it were replaced by
11930 // namespace unique { /* empty body */ }
11931 // using namespace unique;
11932 // namespace unique { namespace-body }
11933 // where all occurrences of 'unique' in a translation unit are
11934 // replaced by the same identifier and this identifier differs
11935 // from all other identifiers in the entire program.
11936
11937 // We just create the namespace with an empty name and then add an
11938 // implicit using declaration, just like the standard suggests.
11939 //
11940 // CodeGen enforces the "universally unique" aspect by giving all
11941 // declarations semantically contained within an anonymous
11942 // namespace internal linkage.
11943
11944 if (!PrevNS) {
11946 /* 'using' */ LBrace,
11947 /* 'namespace' */ SourceLocation(),
11948 /* qualifier */ NestedNameSpecifierLoc(),
11949 /* identifier */ SourceLocation(),
11950 Namespc,
11951 /* Ancestor */ Parent);
11952 UD->setImplicit();
11953 Parent->addDecl(UD);
11954 }
11955 }
11956
11957 ActOnDocumentableDecl(Namespc);
11958
11959 // Although we could have an invalid decl (i.e. the namespace name is a
11960 // redefinition), push it as current DeclContext and try to continue parsing.
11961 // FIXME: We should be able to push Namespc here, so that the each DeclContext
11962 // for the namespace has the declarations that showed up in that particular
11963 // namespace definition.
11964 PushDeclContext(NamespcScope, Namespc);
11965 return Namespc;
11966}
11967
11968/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
11969/// is a namespace alias, returns the namespace it points to.
11971 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
11972 return AD->getNamespace();
11973 return dyn_cast_or_null<NamespaceDecl>(D);
11974}
11975
11977 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
11978 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
11979 Namespc->setRBraceLoc(RBrace);
11981 if (Namespc->hasAttr<VisibilityAttr>())
11982 PopPragmaVisibility(true, RBrace);
11983 // If this namespace contains an export-declaration, export it now.
11984 if (DeferredExportedNamespaces.erase(Namespc))
11986}
11987
11989 return cast_or_null<CXXRecordDecl>(
11991}
11992
11994 return cast_or_null<EnumDecl>(StdAlignValT.get(Context.getExternalSource()));
11995}
11996
11998 return cast_or_null<NamespaceDecl>(
12000}
12001
12002namespace {
12003
12004enum UnsupportedSTLSelect {
12005 USS_InvalidMember,
12006 USS_MissingMember,
12007 USS_NonTrivial,
12008 USS_Other
12009};
12010
12011struct InvalidSTLDiagnoser {
12012 Sema &S;
12014 QualType TyForDiags;
12015
12016 QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name = "",
12017 const VarDecl *VD = nullptr) {
12018 {
12019 auto D = S.Diag(Loc, diag::err_std_compare_type_not_supported)
12020 << TyForDiags << ((int)Sel);
12021 if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
12022 assert(!Name.empty());
12023 D << Name;
12024 }
12025 }
12026 if (Sel == USS_InvalidMember) {
12027 S.Diag(VD->getLocation(), diag::note_var_declared_here)
12028 << VD << VD->getSourceRange();
12029 }
12030 return QualType();
12031 }
12032};
12033} // namespace
12034
12038 assert(getLangOpts().CPlusPlus &&
12039 "Looking for comparison category type outside of C++.");
12040
12041 // Use an elaborated type for diagnostics which has a name containing the
12042 // prepended 'std' namespace but not any inline namespace names.
12043 auto TyForDiags = [&](ComparisonCategoryInfo *Info) {
12045 /*Prefix=*/std::nullopt);
12047 Info->Record,
12048 /*OwnsTag=*/false);
12049 };
12050
12051 // Check if we've already successfully checked the comparison category type
12052 // before. If so, skip checking it again.
12054 if (Info && FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)]) {
12055 // The only thing we need to check is that the type has a reachable
12056 // definition in the current context.
12057 if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
12058 return QualType();
12059
12060 return Info->getType();
12061 }
12062
12063 // If lookup failed
12064 if (!Info) {
12065 std::string NameForDiags = "std::";
12066 NameForDiags += ComparisonCategories::getCategoryString(Kind);
12067 Diag(Loc, diag::err_implied_comparison_category_type_not_found)
12068 << NameForDiags << (int)Usage;
12069 return QualType();
12070 }
12071
12072 assert(Info->Kind == Kind);
12073 assert(Info->Record);
12074
12075 // Update the Record decl in case we encountered a forward declaration on our
12076 // first pass. FIXME: This is a bit of a hack.
12077 if (Info->Record->hasDefinition())
12078 Info->Record = Info->Record->getDefinition();
12079
12080 if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
12081 return QualType();
12082
12083 InvalidSTLDiagnoser UnsupportedSTLError{*this, Loc, TyForDiags(Info)};
12084
12085 if (!Info->Record->isTriviallyCopyable())
12086 return UnsupportedSTLError(USS_NonTrivial);
12087
12088 for (const CXXBaseSpecifier &BaseSpec : Info->Record->bases()) {
12089 CXXRecordDecl *Base = BaseSpec.getType()->getAsCXXRecordDecl();
12090 // Tolerate empty base classes.
12091 if (Base->isEmpty())
12092 continue;
12093 // Reject STL implementations which have at least one non-empty base.
12094 return UnsupportedSTLError();
12095 }
12096
12097 // Check that the STL has implemented the types using a single integer field.
12098 // This expectation allows better codegen for builtin operators. We require:
12099 // (1) The class has exactly one field.
12100 // (2) The field is an integral or enumeration type.
12101 auto FIt = Info->Record->field_begin(), FEnd = Info->Record->field_end();
12102 if (std::distance(FIt, FEnd) != 1 ||
12103 !FIt->getType()->isIntegralOrEnumerationType()) {
12104 return UnsupportedSTLError();
12105 }
12106
12107 // Build each of the require values and store them in Info.
12108 for (ComparisonCategoryResult CCR :
12110 StringRef MemName = ComparisonCategories::getResultString(CCR);
12111 ComparisonCategoryInfo::ValueInfo *ValInfo = Info->lookupValueInfo(CCR);
12112
12113 if (!ValInfo)
12114 return UnsupportedSTLError(USS_MissingMember, MemName);
12115
12116 VarDecl *VD = ValInfo->VD;
12117 assert(VD && "should not be null!");
12118
12119 // Attempt to diagnose reasons why the STL definition of this type
12120 // might be foobar, including it failing to be a constant expression.
12121 // TODO Handle more ways the lookup or result can be invalid.
12122 if (!VD->isStaticDataMember() ||
12124 return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
12125
12126 // Attempt to evaluate the var decl as a constant expression and extract
12127 // the value of its first field as a ICE. If this fails, the STL
12128 // implementation is not supported.
12129 if (!ValInfo->hasValidIntValue())
12130 return UnsupportedSTLError();
12131
12133 }
12134
12135 // We've successfully built the required types and expressions. Update
12136 // the cache and return the newly cached value.
12137 FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)] = true;
12138 return Info->getType();
12139}
12140
12142 if (!StdNamespace) {
12143 // The "std" namespace has not yet been defined, so build one implicitly.
12146 /*Inline=*/false, SourceLocation(), SourceLocation(),
12147 &PP.getIdentifierTable().get("std"),
12148 /*PrevDecl=*/nullptr, /*Nested=*/false);
12150 // We want the created NamespaceDecl to be available for redeclaration
12151 // lookups, but not for regular name lookups.
12154 }
12155
12156 return getStdNamespace();
12157}
12158
12159static bool isStdClassTemplate(Sema &S, QualType SugaredType, QualType *TypeArg,
12160 const char *ClassName,
12161 ClassTemplateDecl **CachedDecl,
12162 const Decl **MalformedDecl) {
12163 // We're looking for implicit instantiations of
12164 // template <typename U> class std::{ClassName}.
12165
12166 if (!S.StdNamespace) // If we haven't seen namespace std yet, this can't be
12167 // it.
12168 return false;
12169
12170 auto ReportMatchingNameAsMalformed = [&](NamedDecl *D) {
12171 if (!MalformedDecl)
12172 return;
12173 if (!D)
12174 D = SugaredType->getAsTagDecl();
12175 if (!D || !D->isInStdNamespace())
12176 return;
12177 IdentifierInfo *II = D->getDeclName().getAsIdentifierInfo();
12178 if (II && II == &S.PP.getIdentifierTable().get(ClassName))
12179 *MalformedDecl = D;
12180 };
12181
12182 ClassTemplateDecl *Template = nullptr;
12184 if (const TemplateSpecializationType *TST =
12186 Template = dyn_cast_or_null<ClassTemplateDecl>(
12187 TST->getTemplateName().getAsTemplateDecl());
12188 Arguments = TST->template_arguments();
12189 } else if (const auto *TT = SugaredType->getAs<TagType>()) {
12190 Template = TT->getTemplateDecl();
12191 Arguments = TT->getTemplateArgs(S.Context);
12192 }
12193
12194 if (!Template) {
12195 ReportMatchingNameAsMalformed(SugaredType->getAsTagDecl());
12196 return false;
12197 }
12198
12199 if (!*CachedDecl) {
12200 // Haven't recognized std::{ClassName} yet, maybe this is it.
12201 // FIXME: It seems we should just reuse LookupStdClassTemplate but the
12202 // semantics of this are slightly different, most notably the existing
12203 // "lookup" semantics explicitly diagnose an invalid definition as an
12204 // error.
12205 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
12206 if (TemplateClass->getIdentifier() !=
12207 &S.PP.getIdentifierTable().get(ClassName) ||
12209 TemplateClass->getNonTransparentDeclContext()))
12210 return false;
12211 // This is a template called std::{ClassName}, but is it the right
12212 // template?
12213 TemplateParameterList *Params = Template->getTemplateParameters();
12214 if (Params->getMinRequiredArguments() != 1 ||
12215 !isa<TemplateTypeParmDecl>(Params->getParam(0)) ||
12216 Params->getParam(0)->isTemplateParameterPack()) {
12217 if (MalformedDecl)
12218 *MalformedDecl = TemplateClass;
12219 return false;
12220 }
12221
12222 // It's the right template.
12223 *CachedDecl = Template;
12224 }
12225
12226 if (Template->getCanonicalDecl() != (*CachedDecl)->getCanonicalDecl())
12227 return false;
12228
12229 // This is an instance of std::{ClassName}. Find the argument type.
12230 if (TypeArg) {
12231 QualType ArgType = Arguments[0].getAsType();
12232 // FIXME: Since TST only has as-written arguments, we have to perform the
12233 // only kind of conversion applicable to type arguments; in Objective-C ARC:
12234 // - If an explicitly-specified template argument type is a lifetime type
12235 // with no lifetime qualifier, the __strong lifetime qualifier is
12236 // inferred.
12237 if (S.getLangOpts().ObjCAutoRefCount && ArgType->isObjCLifetimeType() &&
12238 !ArgType.getObjCLifetime()) {
12239 Qualifiers Qs;
12241 ArgType = S.Context.getQualifiedType(ArgType, Qs);
12242 }
12243 *TypeArg = ArgType;
12244 }
12245
12246 return true;
12247}
12248
12250 assert(getLangOpts().CPlusPlus &&
12251 "Looking for std::initializer_list outside of C++.");
12252
12253 // We're looking for implicit instantiations of
12254 // template <typename E> class std::initializer_list.
12255
12256 return isStdClassTemplate(*this, Ty, Element, "initializer_list",
12257 &StdInitializerList, /*MalformedDecl=*/nullptr);
12258}
12259
12261 const Decl **MalformedDecl) {
12262 assert(getLangOpts().CPlusPlus &&
12263 "Looking for std::type_identity outside of C++.");
12264
12265 // We're looking for implicit instantiations of
12266 // template <typename T> struct std::type_identity.
12267
12268 return isStdClassTemplate(*this, Ty, Element, "type_identity",
12269 &StdTypeIdentity, MalformedDecl);
12270}
12271
12273 const char *ClassName,
12274 bool *WasMalformed) {
12275 if (!S.StdNamespace)
12276 return nullptr;
12277
12278 LookupResult Result(S, &S.PP.getIdentifierTable().get(ClassName), Loc,
12281 return nullptr;
12282
12284 if (!Template) {
12285 Result.suppressDiagnostics();
12286 // We found something weird. Complain about the first thing we found.
12287 NamedDecl *Found = *Result.begin();
12288 S.Diag(Found->getLocation(), diag::err_malformed_std_class_template)
12289 << ClassName;
12290 if (WasMalformed)
12291 *WasMalformed = true;
12292 return nullptr;
12293 }
12294
12295 // We found some template with the correct name. Now verify that it's
12296 // correct.
12297 TemplateParameterList *Params = Template->getTemplateParameters();
12298 if (Params->getMinRequiredArguments() != 1 ||
12299 !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
12300 S.Diag(Template->getLocation(), diag::err_malformed_std_class_template)
12301 << ClassName;
12302 if (WasMalformed)
12303 *WasMalformed = true;
12304 return nullptr;
12305 }
12306
12307 return Template;
12308}
12309
12311 QualType TypeParam, SourceLocation Loc) {
12312 assert(S.getStdNamespace());
12314 auto TSI = S.Context.getTrivialTypeSourceInfo(TypeParam, Loc);
12315 Args.addArgument(TemplateArgumentLoc(TemplateArgument(TypeParam), TSI));
12316
12318 Loc, Args);
12319}
12320
12322 if (!StdInitializerList) {
12323 bool WasMalformed = false;
12325 LookupStdClassTemplate(*this, Loc, "initializer_list", &WasMalformed);
12326 if (!StdInitializerList) {
12327 if (!WasMalformed)
12328 Diag(Loc, diag::err_implied_std_initializer_list_not_found);
12329 return QualType();
12330 }
12331 }
12332 return BuildStdClassTemplate(*this, StdInitializerList, Element, Loc);
12333}
12334
12336 if (!StdTypeIdentity) {
12337 StdTypeIdentity = LookupStdClassTemplate(*this, Loc, "type_identity",
12338 /*WasMalformed=*/nullptr);
12339 if (!StdTypeIdentity)
12340 return QualType();
12341 }
12343}
12344
12346 // C++ [dcl.init.list]p2:
12347 // A constructor is an initializer-list constructor if its first parameter
12348 // is of type std::initializer_list<E> or reference to possibly cv-qualified
12349 // std::initializer_list<E> for some type E, and either there are no other
12350 // parameters or else all other parameters have default arguments.
12351 if (!Ctor->hasOneParamOrDefaultArgs())
12352 return false;
12353
12354 QualType ArgType = Ctor->getParamDecl(0)->getType();
12355 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
12356 ArgType = RT->getPointeeType().getUnqualifiedType();
12357
12358 return isStdInitializerList(ArgType, nullptr);
12359}
12360
12361/// Determine whether a using statement is in a context where it will be
12362/// apply in all contexts.
12364 switch (CurContext->getDeclKind()) {
12365 case Decl::TranslationUnit:
12366 return true;
12367 case Decl::LinkageSpec:
12369 default:
12370 return false;
12371 }
12372}
12373
12374namespace {
12375
12376// Callback to only accept typo corrections that are namespaces.
12377class NamespaceValidatorCCC final : public CorrectionCandidateCallback {
12378public:
12379 bool ValidateCandidate(const TypoCorrection &candidate) override {
12380 if (NamedDecl *ND = candidate.getCorrectionDecl())
12381 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
12382 return false;
12383 }
12384
12385 std::unique_ptr<CorrectionCandidateCallback> clone() override {
12386 return std::make_unique<NamespaceValidatorCCC>(*this);
12387 }
12388};
12389
12390}
12391
12392static void DiagnoseInvisibleNamespace(const TypoCorrection &Corrected,
12393 Sema &S) {
12394 auto *ND = cast<NamespaceDecl>(Corrected.getFoundDecl());
12395 Module *M = ND->getOwningModule();
12396 assert(M && "hidden namespace definition not in a module?");
12397
12398 if (M->isExplicitGlobalModule())
12399 S.Diag(Corrected.getCorrectionRange().getBegin(),
12400 diag::err_module_unimported_use_header)
12402 << /*Header Name*/ false;
12403 else
12404 S.Diag(Corrected.getCorrectionRange().getBegin(),
12405 diag::err_module_unimported_use)
12407 << M->getTopLevelModuleName();
12408}
12409
12411 CXXScopeSpec &SS,
12412 SourceLocation IdentLoc,
12413 IdentifierInfo *Ident) {
12414 R.clear();
12415 NamespaceValidatorCCC CCC{};
12416 if (TypoCorrection Corrected =
12417 S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS, CCC,
12419 // Generally we find it is confusing more than helpful to diagnose the
12420 // invisible namespace.
12421 // See https://github.com/llvm/llvm-project/issues/73893.
12422 //
12423 // However, we should diagnose when the users are trying to using an
12424 // invisible namespace. So we handle the case specially here.
12425 if (isa_and_nonnull<NamespaceDecl>(Corrected.getFoundDecl()) &&
12426 Corrected.requiresImport()) {
12427 DiagnoseInvisibleNamespace(Corrected, S);
12428 } else if (DeclContext *DC = S.computeDeclContext(SS, false)) {
12429 std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
12430 bool DroppedSpecifier =
12431 Corrected.WillReplaceSpecifier() && Ident->getName() == CorrectedStr;
12432 S.diagnoseTypo(Corrected,
12433 S.PDiag(diag::err_using_directive_member_suggest)
12434 << Ident << DC << DroppedSpecifier << SS.getRange(),
12435 S.PDiag(diag::note_namespace_defined_here));
12436 } else {
12437 S.diagnoseTypo(Corrected,
12438 S.PDiag(diag::err_using_directive_suggest) << Ident,
12439 S.PDiag(diag::note_namespace_defined_here));
12440 }
12441 R.addDecl(Corrected.getFoundDecl());
12442 return true;
12443 }
12444 return false;
12445}
12446
12448 SourceLocation NamespcLoc, CXXScopeSpec &SS,
12449 SourceLocation IdentLoc,
12450 IdentifierInfo *NamespcName,
12451 const ParsedAttributesView &AttrList) {
12452 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
12453 assert(NamespcName && "Invalid NamespcName.");
12454 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
12455
12456 // Get the innermost enclosing declaration scope.
12457 S = S->getDeclParent();
12458
12459 UsingDirectiveDecl *UDir = nullptr;
12460 NestedNameSpecifier Qualifier = SS.getScopeRep();
12461
12462 // Lookup namespace name.
12463 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
12464 LookupParsedName(R, S, &SS, /*ObjectType=*/QualType());
12465 if (R.isAmbiguous())
12466 return nullptr;
12467
12468 if (R.empty()) {
12469 R.clear();
12470 // Allow "using namespace std;" or "using namespace ::std;" even if
12471 // "std" hasn't been defined yet, for GCC compatibility.
12472 if ((!Qualifier ||
12473 Qualifier.getKind() == NestedNameSpecifier::Kind::Global) &&
12474 NamespcName->isStr("std")) {
12475 Diag(IdentLoc, diag::ext_using_undefined_std);
12477 R.resolveKind();
12478 }
12479 // Otherwise, attempt typo correction.
12480 else
12481 TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
12482 }
12483
12484 if (!R.empty()) {
12485 NamedDecl *Named = R.getRepresentativeDecl();
12487 assert(NS && "expected namespace decl");
12488
12489 // The use of a nested name specifier may trigger deprecation warnings.
12490 DiagnoseUseOfDecl(Named, IdentLoc);
12491
12492 // C++ [namespace.udir]p1:
12493 // A using-directive specifies that the names in the nominated
12494 // namespace can be used in the scope in which the
12495 // using-directive appears after the using-directive. During
12496 // unqualified name lookup (3.4.1), the names appear as if they
12497 // were declared in the nearest enclosing namespace which
12498 // contains both the using-directive and the nominated
12499 // namespace. [Note: in this context, "contains" means "contains
12500 // directly or indirectly". ]
12501
12502 // Find enclosing context containing both using-directive and
12503 // nominated namespace.
12504 DeclContext *CommonAncestor = NS;
12505 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
12506 CommonAncestor = CommonAncestor->getParent();
12507
12508 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
12510 IdentLoc, Named, CommonAncestor);
12511
12514 Diag(IdentLoc, diag::warn_using_directive_in_header);
12515 }
12516
12517 PushUsingDirective(S, UDir);
12518 } else {
12519 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
12520 }
12521
12522 if (UDir) {
12523 ProcessDeclAttributeList(S, UDir, AttrList);
12524 ProcessAPINotes(UDir);
12525 }
12526
12527 return UDir;
12528}
12529
12531 // If the scope has an associated entity and the using directive is at
12532 // namespace or translation unit scope, add the UsingDirectiveDecl into
12533 // its lookup structure so qualified name lookup can find it.
12534 DeclContext *Ctx = S->getEntity();
12535 if (Ctx && !Ctx->isFunctionOrMethod())
12536 Ctx->addDecl(UDir);
12537 else
12538 // Otherwise, it is at block scope. The using-directives will affect lookup
12539 // only to the end of the scope.
12540 S->PushUsingDirective(UDir);
12541}
12542
12544 SourceLocation UsingLoc,
12545 SourceLocation TypenameLoc, CXXScopeSpec &SS,
12546 UnqualifiedId &Name,
12547 SourceLocation EllipsisLoc,
12548 const ParsedAttributesView &AttrList) {
12549 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
12550
12551 if (SS.isEmpty()) {
12552 Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
12553 return nullptr;
12554 }
12555
12556 switch (Name.getKind()) {
12562 break;
12563
12566 // C++11 inheriting constructors.
12567 Diag(Name.getBeginLoc(),
12569 ? diag::warn_cxx98_compat_using_decl_constructor
12570 : diag::err_using_decl_constructor)
12571 << SS.getRange();
12572
12573 if (getLangOpts().CPlusPlus11) break;
12574
12575 return nullptr;
12576
12578 Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.getRange();
12579 return nullptr;
12580
12582 Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
12583 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
12584 return nullptr;
12585
12587 llvm_unreachable("cannot parse qualified deduction guide name");
12588 }
12589
12590 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
12591 DeclarationName TargetName = TargetNameInfo.getName();
12592 if (!TargetName)
12593 return nullptr;
12594
12595 // Warn about access declarations.
12596 if (UsingLoc.isInvalid()) {
12597 Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11
12598 ? diag::err_access_decl
12599 : diag::warn_access_decl_deprecated)
12600 << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
12601 }
12602
12603 if (EllipsisLoc.isInvalid()) {
12606 return nullptr;
12607 } else {
12609 !TargetNameInfo.containsUnexpandedParameterPack()) {
12610 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
12611 << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
12612 EllipsisLoc = SourceLocation();
12613 }
12614 }
12615
12616 NamedDecl *UD =
12617 BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
12618 SS, TargetNameInfo, EllipsisLoc, AttrList,
12619 /*IsInstantiation*/ false,
12620 AttrList.hasAttribute(ParsedAttr::AT_UsingIfExists));
12621 if (UD)
12622 PushOnScopeChains(UD, S, /*AddToContext*/ false);
12623
12624 return UD;
12625}
12626
12628 SourceLocation UsingLoc,
12629 SourceLocation EnumLoc, SourceRange TyLoc,
12630 const IdentifierInfo &II, ParsedType Ty,
12631 CXXScopeSpec *SS) {
12632 assert(SS && !SS->isInvalid() && "ScopeSpec is invalid");
12633 TypeSourceInfo *TSI = nullptr;
12634 SourceLocation IdentLoc = TyLoc.getBegin();
12635 QualType EnumTy = GetTypeFromParser(Ty, &TSI);
12636 if (EnumTy.isNull()) {
12637 Diag(IdentLoc, isDependentScopeSpecifier(*SS)
12638 ? diag::err_using_enum_is_dependent
12639 : diag::err_unknown_typename)
12640 << II.getName() << SourceRange(SS->getBeginLoc(), TyLoc.getEnd());
12641 return nullptr;
12642 }
12643
12644 if (EnumTy->isDependentType()) {
12645 Diag(IdentLoc, diag::err_using_enum_is_dependent);
12646 return nullptr;
12647 }
12648
12649 auto *Enum = EnumTy->getAsEnumDecl();
12650 if (!Enum) {
12651 Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;
12652 return nullptr;
12653 }
12654
12655 if (TSI == nullptr)
12656 TSI = Context.getTrivialTypeSourceInfo(EnumTy, IdentLoc);
12657
12658 auto *UD =
12659 BuildUsingEnumDeclaration(S, AS, UsingLoc, EnumLoc, IdentLoc, TSI, Enum);
12660
12661 if (UD)
12662 PushOnScopeChains(UD, S, /*AddToContext*/ false);
12663
12664 return UD;
12665}
12666
12667/// Determine whether a using declaration considers the given
12668/// declarations as "equivalent", e.g., if they are redeclarations of
12669/// the same entity or are both typedefs of the same type.
12670static bool
12672 if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
12673 return true;
12674
12675 if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
12676 if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
12677 return Context.hasSameType(TD1->getUnderlyingType(),
12678 TD2->getUnderlyingType());
12679
12680 // Two using_if_exists using-declarations are equivalent if both are
12681 // unresolved.
12682 if (isa<UnresolvedUsingIfExistsDecl>(D1) &&
12683 isa<UnresolvedUsingIfExistsDecl>(D2))
12684 return true;
12685
12686 return false;
12687}
12688
12690 const LookupResult &Previous,
12691 UsingShadowDecl *&PrevShadow) {
12692 // Diagnose finding a decl which is not from a base class of the
12693 // current class. We do this now because there are cases where this
12694 // function will silently decide not to build a shadow decl, which
12695 // will pre-empt further diagnostics.
12696 //
12697 // We don't need to do this in C++11 because we do the check once on
12698 // the qualifier.
12699 //
12700 // FIXME: diagnose the following if we care enough:
12701 // struct A { int foo; };
12702 // struct B : A { using A::foo; };
12703 // template <class T> struct C : A {};
12704 // template <class T> struct D : C<T> { using B::foo; } // <---
12705 // This is invalid (during instantiation) in C++03 because B::foo
12706 // resolves to the using decl in B, which is not a base class of D<T>.
12707 // We can't diagnose it immediately because C<T> is an unknown
12708 // specialization. The UsingShadowDecl in D<T> then points directly
12709 // to A::foo, which will look well-formed when we instantiate.
12710 // The right solution is to not collapse the shadow-decl chain.
12712 if (auto *Using = dyn_cast<UsingDecl>(BUD)) {
12713 DeclContext *OrigDC = Orig->getDeclContext();
12714
12715 // Handle enums and anonymous structs.
12716 if (isa<EnumDecl>(OrigDC))
12717 OrigDC = OrigDC->getParent();
12718 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
12719 while (OrigRec->isAnonymousStructOrUnion())
12720 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
12721
12722 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
12723 if (OrigDC == CurContext) {
12724 Diag(Using->getLocation(),
12725 diag::err_using_decl_nested_name_specifier_is_current_class)
12726 << Using->getQualifierLoc().getSourceRange();
12727 Diag(Orig->getLocation(), diag::note_using_decl_target);
12728 Using->setInvalidDecl();
12729 return true;
12730 }
12731
12732 Diag(Using->getQualifierLoc().getBeginLoc(),
12733 diag::err_using_decl_nested_name_specifier_is_not_base_class)
12734 << Using->getQualifier() << cast<CXXRecordDecl>(CurContext)
12735 << Using->getQualifierLoc().getSourceRange();
12736 Diag(Orig->getLocation(), diag::note_using_decl_target);
12737 Using->setInvalidDecl();
12738 return true;
12739 }
12740 }
12741
12742 if (Previous.empty()) return false;
12743
12744 NamedDecl *Target = Orig;
12745 if (isa<UsingShadowDecl>(Target))
12746 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
12747
12748 // If the target happens to be one of the previous declarations, we
12749 // don't have a conflict.
12750 //
12751 // FIXME: but we might be increasing its access, in which case we
12752 // should redeclare it.
12753 NamedDecl *NonTag = nullptr, *Tag = nullptr;
12754 bool FoundEquivalentDecl = false;
12755 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
12756 I != E; ++I) {
12757 NamedDecl *D = (*I)->getUnderlyingDecl();
12758 // We can have UsingDecls in our Previous results because we use the same
12759 // LookupResult for checking whether the UsingDecl itself is a valid
12760 // redeclaration.
12761 if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D) || isa<UsingEnumDecl>(D))
12762 continue;
12763
12764 if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
12765 // C++ [class.mem]p19:
12766 // If T is the name of a class, then [every named member other than
12767 // a non-static data member] shall have a name different from T
12768 if (RD->isInjectedClassName() && !isa<FieldDecl>(Target) &&
12769 !isa<IndirectFieldDecl>(Target) &&
12770 !isa<UnresolvedUsingValueDecl>(Target) &&
12772 CurContext,
12774 return true;
12775 }
12776
12778 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
12779 PrevShadow = Shadow;
12780 FoundEquivalentDecl = true;
12782 // We don't conflict with an existing using shadow decl of an equivalent
12783 // declaration, but we're not a redeclaration of it.
12784 FoundEquivalentDecl = true;
12785 }
12786
12787 if (isVisible(D))
12788 (isa<TagDecl>(D) ? Tag : NonTag) = D;
12789 }
12790
12791 if (FoundEquivalentDecl)
12792 return false;
12793
12794 // Always emit a diagnostic for a mismatch between an unresolved
12795 // using_if_exists and a resolved using declaration in either direction.
12796 if (isa<UnresolvedUsingIfExistsDecl>(Target) !=
12797 (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {
12798 if (!NonTag && !Tag)
12799 return false;
12800 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12801 Diag(Target->getLocation(), diag::note_using_decl_target);
12802 Diag((NonTag ? NonTag : Tag)->getLocation(),
12803 diag::note_using_decl_conflict);
12804 BUD->setInvalidDecl();
12805 return true;
12806 }
12807
12808 if (FunctionDecl *FD = Target->getAsFunction()) {
12809 NamedDecl *OldDecl = nullptr;
12810 switch (CheckOverload(nullptr, FD, Previous, OldDecl,
12811 /*IsForUsingDecl*/ true)) {
12813 return false;
12814
12816 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12817 break;
12818
12819 // We found a decl with the exact signature.
12821 // If we're in a record, we want to hide the target, so we
12822 // return true (without a diagnostic) to tell the caller not to
12823 // build a shadow decl.
12824 if (CurContext->isRecord())
12825 return true;
12826
12827 // If we're not in a record, this is an error.
12828 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12829 break;
12830 }
12831
12832 Diag(Target->getLocation(), diag::note_using_decl_target);
12833 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
12834 BUD->setInvalidDecl();
12835 return true;
12836 }
12837
12838 // Target is not a function.
12839
12840 if (isa<TagDecl>(Target)) {
12841 // No conflict between a tag and a non-tag.
12842 if (!Tag) return false;
12843
12844 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12845 Diag(Target->getLocation(), diag::note_using_decl_target);
12846 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
12847 BUD->setInvalidDecl();
12848 return true;
12849 }
12850
12851 // No conflict between a tag and a non-tag.
12852 if (!NonTag) return false;
12853
12854 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12855 Diag(Target->getLocation(), diag::note_using_decl_target);
12856 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
12857 BUD->setInvalidDecl();
12858 return true;
12859}
12860
12861/// Determine whether a direct base class is a virtual base class.
12863 if (!Derived->getNumVBases())
12864 return false;
12865 for (auto &B : Derived->bases())
12866 if (B.getType()->getAsCXXRecordDecl() == Base)
12867 return B.isVirtual();
12868 llvm_unreachable("not a direct base class");
12869}
12870
12872 NamedDecl *Orig,
12873 UsingShadowDecl *PrevDecl) {
12874 // If we resolved to another shadow declaration, just coalesce them.
12875 NamedDecl *Target = Orig;
12876 if (isa<UsingShadowDecl>(Target)) {
12877 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
12878 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
12879 }
12880
12881 NamedDecl *NonTemplateTarget = Target;
12882 if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
12883 NonTemplateTarget = TargetTD->getTemplatedDecl();
12884
12885 UsingShadowDecl *Shadow;
12886 if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
12887 UsingDecl *Using = cast<UsingDecl>(BUD);
12888 bool IsVirtualBase =
12889 isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
12890 Using->getQualifier().getAsRecordDecl());
12892 Context, CurContext, Using->getLocation(), Using, Orig, IsVirtualBase);
12893 } else {
12895 Target->getDeclName(), BUD, Target);
12896 }
12897 BUD->addShadowDecl(Shadow);
12898
12899 Shadow->setAccess(BUD->getAccess());
12900 if (Orig->isInvalidDecl() || BUD->isInvalidDecl())
12901 Shadow->setInvalidDecl();
12902
12903 Shadow->setPreviousDecl(PrevDecl);
12904
12905 if (S)
12906 PushOnScopeChains(Shadow, S);
12907 else
12908 CurContext->addDecl(Shadow);
12909
12910
12911 return Shadow;
12912}
12913
12915 if (Shadow->getDeclName().getNameKind() ==
12917 cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
12918
12919 // Remove it from the DeclContext...
12920 Shadow->getDeclContext()->removeDecl(Shadow);
12921
12922 // ...and the scope, if applicable...
12923 if (S) {
12924 S->RemoveDecl(Shadow);
12925 IdResolver.RemoveDecl(Shadow);
12926 }
12927
12928 // ...and the using decl.
12929 Shadow->getIntroducer()->removeShadowDecl(Shadow);
12930
12931 // TODO: complain somehow if Shadow was used. It shouldn't
12932 // be possible for this to happen, because...?
12933}
12934
12935/// Find the base specifier for a base class with the given type.
12937 QualType DesiredBase,
12938 bool &AnyDependentBases) {
12939 // Check whether the named type is a direct base class.
12940 CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified()
12942 for (auto &Base : Derived->bases()) {
12943 CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
12944 if (CanonicalDesiredBase == BaseType)
12945 return &Base;
12946 if (BaseType->isDependentType())
12947 AnyDependentBases = true;
12948 }
12949 return nullptr;
12950}
12951
12952namespace {
12953class UsingValidatorCCC final : public CorrectionCandidateCallback {
12954public:
12955 UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
12956 NestedNameSpecifier NNS, CXXRecordDecl *RequireMemberOf)
12957 : HasTypenameKeyword(HasTypenameKeyword),
12958 IsInstantiation(IsInstantiation), OldNNS(NNS),
12959 RequireMemberOf(RequireMemberOf) {}
12960
12961 bool ValidateCandidate(const TypoCorrection &Candidate) override {
12962 NamedDecl *ND = Candidate.getCorrectionDecl();
12963
12964 // Keywords are not valid here.
12965 if (!ND || isa<NamespaceDecl>(ND))
12966 return false;
12967
12968 // Completely unqualified names are invalid for a 'using' declaration.
12969 if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
12970 return false;
12971
12972 // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
12973 // reject.
12974
12975 if (RequireMemberOf) {
12976 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12977 if (FoundRecord && FoundRecord->isInjectedClassName()) {
12978 // No-one ever wants a using-declaration to name an injected-class-name
12979 // of a base class, unless they're declaring an inheriting constructor.
12980 ASTContext &Ctx = ND->getASTContext();
12981 if (!Ctx.getLangOpts().CPlusPlus11)
12982 return false;
12983 CanQualType FoundType = Ctx.getCanonicalTagType(FoundRecord);
12984
12985 // Check that the injected-class-name is named as a member of its own
12986 // type; we don't want to suggest 'using Derived::Base;', since that
12987 // means something else.
12989 ? Candidate.getCorrectionSpecifier()
12990 : OldNNS;
12991 if (Specifier.getKind() != NestedNameSpecifier::Kind::Type ||
12992 !Ctx.hasSameType(QualType(Specifier.getAsType(), 0), FoundType))
12993 return false;
12994
12995 // Check that this inheriting constructor declaration actually names a
12996 // direct base class of the current class.
12997 bool AnyDependentBases = false;
12998 if (!findDirectBaseWithType(RequireMemberOf,
12999 Ctx.getCanonicalTagType(FoundRecord),
13000 AnyDependentBases) &&
13001 !AnyDependentBases)
13002 return false;
13003 } else {
13004 auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
13005 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
13006 return false;
13007
13008 // FIXME: Check that the base class member is accessible?
13009 }
13010 } else {
13011 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
13012 if (FoundRecord && FoundRecord->isInjectedClassName())
13013 return false;
13014 }
13015
13016 if (isa<TypeDecl>(ND))
13017 return HasTypenameKeyword || !IsInstantiation;
13018
13019 return !HasTypenameKeyword;
13020 }
13021
13022 std::unique_ptr<CorrectionCandidateCallback> clone() override {
13023 return std::make_unique<UsingValidatorCCC>(*this);
13024 }
13025
13026private:
13027 bool HasTypenameKeyword;
13028 bool IsInstantiation;
13029 NestedNameSpecifier OldNNS;
13030 CXXRecordDecl *RequireMemberOf;
13031};
13032} // end anonymous namespace
13033
13035 // It is really dumb that we have to do this.
13036 LookupResult::Filter F = Previous.makeFilter();
13037 while (F.hasNext()) {
13038 NamedDecl *D = F.next();
13039 if (!isDeclInScope(D, CurContext, S))
13040 F.erase();
13041 // If we found a local extern declaration that's not ordinarily visible,
13042 // and this declaration is being added to a non-block scope, ignore it.
13043 // We're only checking for scope conflicts here, not also for violations
13044 // of the linkage rules.
13045 else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
13047 F.erase();
13048 }
13049 F.done();
13050}
13051
13053 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
13054 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
13055 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
13056 const ParsedAttributesView &AttrList, bool IsInstantiation,
13057 bool IsUsingIfExists) {
13058 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
13059 SourceLocation IdentLoc = NameInfo.getLoc();
13060 assert(IdentLoc.isValid() && "Invalid TargetName location.");
13061
13062 // FIXME: We ignore attributes for now.
13063
13064 // For an inheriting constructor declaration, the name of the using
13065 // declaration is the name of a constructor in this class, not in the
13066 // base class.
13067 DeclarationNameInfo UsingName = NameInfo;
13069 if (auto *RD = dyn_cast<CXXRecordDecl>(CurContext))
13072
13073 // Do the redeclaration lookup in the current scope.
13074 LookupResult Previous(*this, UsingName, LookupUsingDeclName,
13075 RedeclarationKind::ForVisibleRedeclaration);
13076 Previous.setHideTags(false);
13077 if (S) {
13078 LookupName(Previous, S);
13079
13081 } else {
13082 assert(IsInstantiation && "no scope in non-instantiation");
13083 if (CurContext->isRecord())
13085 else {
13086 // No redeclaration check is needed here; in non-member contexts we
13087 // diagnosed all possible conflicts with other using-declarations when
13088 // building the template:
13089 //
13090 // For a dependent non-type using declaration, the only valid case is
13091 // if we instantiate to a single enumerator. We check for conflicts
13092 // between shadow declarations we introduce, and we check in the template
13093 // definition for conflicts between a non-type using declaration and any
13094 // other declaration, which together covers all cases.
13095 //
13096 // A dependent typename using declaration will never successfully
13097 // instantiate, since it will always name a class member, so we reject
13098 // that in the template definition.
13099 }
13100 }
13101
13102 // Check for invalid redeclarations.
13103 if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
13104 SS, IdentLoc, Previous))
13105 return nullptr;
13106
13107 // 'using_if_exists' doesn't make sense on an inherited constructor.
13108 if (IsUsingIfExists && UsingName.getName().getNameKind() ==
13110 Diag(UsingLoc, diag::err_using_if_exists_on_ctor);
13111 return nullptr;
13112 }
13113
13114 DeclContext *LookupContext = computeDeclContext(SS);
13116 if (!LookupContext || EllipsisLoc.isValid()) {
13117 NamedDecl *D;
13118 // Dependent scope, or an unexpanded pack
13119 if (!LookupContext && CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword,
13120 SS, NameInfo, IdentLoc))
13121 return nullptr;
13122
13123 if (Previous.isSingleResult() &&
13124 Previous.getFoundDecl()->isTemplateParameter())
13125 DiagnoseTemplateParameterShadow(IdentLoc, Previous.getFoundDecl());
13126
13127 if (HasTypenameKeyword) {
13128 // FIXME: not all declaration name kinds are legal here
13130 UsingLoc, TypenameLoc,
13131 QualifierLoc,
13132 IdentLoc, NameInfo.getName(),
13133 EllipsisLoc);
13134 } else {
13136 QualifierLoc, NameInfo, EllipsisLoc);
13137 }
13138 D->setAccess(AS);
13140 ProcessDeclAttributeList(S, D, AttrList);
13141 return D;
13142 }
13143
13144 auto Build = [&](bool Invalid) {
13145 UsingDecl *UD =
13146 UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
13147 UsingName, HasTypenameKeyword);
13148 UD->setAccess(AS);
13149 CurContext->addDecl(UD);
13150 ProcessDeclAttributeList(S, UD, AttrList);
13152 return UD;
13153 };
13154 auto BuildInvalid = [&]{ return Build(true); };
13155 auto BuildValid = [&]{ return Build(false); };
13156
13157 if (RequireCompleteDeclContext(SS, LookupContext))
13158 return BuildInvalid();
13159
13160 // Look up the target name.
13161 LookupResult R(*this, NameInfo, LookupOrdinaryName);
13162
13163 // Unlike most lookups, we don't always want to hide tag
13164 // declarations: tag names are visible through the using declaration
13165 // even if hidden by ordinary names, *except* in a dependent context
13166 // where they may be used by two-phase lookup.
13167 if (!IsInstantiation)
13168 R.setHideTags(false);
13169
13170 // For the purposes of this lookup, we have a base object type
13171 // equal to that of the current context.
13172 if (CurContext->isRecord()) {
13174 Context.getCanonicalTagType(cast<CXXRecordDecl>(CurContext)));
13175 }
13176
13177 LookupQualifiedName(R, LookupContext);
13178
13179 // Validate the context, now we have a lookup
13180 if (CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword, SS, NameInfo,
13181 IdentLoc, &R))
13182 return nullptr;
13183
13184 if (R.empty() && IsUsingIfExists)
13186 UsingName.getName()),
13187 AS_public);
13188
13189 // Try to correct typos if possible. If constructor name lookup finds no
13190 // results, that means the named class has no explicit constructors, and we
13191 // suppressed declaring implicit ones (probably because it's dependent or
13192 // invalid).
13193 if (R.empty() &&
13195 // HACK 2017-01-08: Work around an issue with libstdc++'s detection of
13196 // ::gets. Sometimes it believes that glibc provides a ::gets in cases where
13197 // it does not. The issue was fixed in libstdc++ 6.3 (2016-12-21) and later.
13198 auto *II = NameInfo.getName().getAsIdentifierInfo();
13199 if (getLangOpts().CPlusPlus14 && II && II->isStr("gets") &&
13201 isa<TranslationUnitDecl>(LookupContext) &&
13202 PP.NeedsStdLibCxxWorkaroundBefore(2016'12'21) &&
13203 getSourceManager().isInSystemHeader(UsingLoc))
13204 return nullptr;
13205 UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
13206 dyn_cast<CXXRecordDecl>(CurContext));
13207 if (TypoCorrection Corrected =
13208 CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS, CCC,
13210 // We reject candidates where DroppedSpecifier == true, hence the
13211 // literal '0' below.
13212 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
13213 << NameInfo.getName() << LookupContext << 0
13214 << SS.getRange());
13215
13216 // If we picked a correction with no attached Decl we can't do anything
13217 // useful with it, bail out.
13218 NamedDecl *ND = Corrected.getCorrectionDecl();
13219 if (!ND)
13220 return BuildInvalid();
13221
13222 // If we corrected to an inheriting constructor, handle it as one.
13223 auto *RD = dyn_cast<CXXRecordDecl>(ND);
13224 if (RD && RD->isInjectedClassName()) {
13225 // The parent of the injected class name is the class itself.
13226 RD = cast<CXXRecordDecl>(RD->getParent());
13227
13228 // Fix up the information we'll use to build the using declaration.
13229 if (Corrected.WillReplaceSpecifier()) {
13231 Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
13232 QualifierLoc.getSourceRange());
13233 QualifierLoc = Builder.getWithLocInContext(Context);
13234 }
13235
13236 // In this case, the name we introduce is the name of a derived class
13237 // constructor.
13238 auto *CurClass = cast<CXXRecordDecl>(CurContext);
13240 Context.getCanonicalTagType(CurClass)));
13241 UsingName.setNamedTypeInfo(nullptr);
13242 for (auto *Ctor : LookupConstructors(RD))
13243 R.addDecl(Ctor);
13244 R.resolveKind();
13245 } else {
13246 // FIXME: Pick up all the declarations if we found an overloaded
13247 // function.
13248 UsingName.setName(ND->getDeclName());
13249 R.addDecl(ND);
13250 }
13251 } else {
13252 Diag(IdentLoc, diag::err_no_member)
13253 << NameInfo.getName() << LookupContext << SS.getRange();
13254 return BuildInvalid();
13255 }
13256 }
13257
13258 if (R.isAmbiguous())
13259 return BuildInvalid();
13260
13261 if (HasTypenameKeyword) {
13262 // If we asked for a typename and got a non-type decl, error out.
13263 if (!R.getAsSingle<TypeDecl>() &&
13265 Diag(IdentLoc, diag::err_using_typename_non_type);
13266 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
13267 Diag((*I)->getUnderlyingDecl()->getLocation(),
13268 diag::note_using_decl_target);
13269 return BuildInvalid();
13270 }
13271 } else {
13272 // If we asked for a non-typename and we got a type, error out,
13273 // but only if this is an instantiation of an unresolved using
13274 // decl. Otherwise just silently find the type name.
13275 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
13276 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
13277 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
13278 return BuildInvalid();
13279 }
13280 }
13281
13282 // C++14 [namespace.udecl]p6:
13283 // A using-declaration shall not name a namespace.
13284 if (R.getAsSingle<NamespaceDecl>()) {
13285 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
13286 << SS.getRange();
13287 // Suggest using 'using namespace ...' instead.
13288 Diag(SS.getBeginLoc(), diag::note_namespace_using_decl)
13289 << FixItHint::CreateInsertion(SS.getBeginLoc(), "namespace ");
13290 return BuildInvalid();
13291 }
13292
13293 UsingDecl *UD = BuildValid();
13294
13295 // Some additional rules apply to inheriting constructors.
13296 if (UsingName.getName().getNameKind() ==
13298 // Suppress access diagnostics; the access check is instead performed at the
13299 // point of use for an inheriting constructor.
13302 return UD;
13303 }
13304
13305 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
13306 UsingShadowDecl *PrevDecl = nullptr;
13307 if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
13308 BuildUsingShadowDecl(S, UD, *I, PrevDecl);
13309 }
13310
13311 return UD;
13312}
13313
13315 SourceLocation UsingLoc,
13316 SourceLocation EnumLoc,
13317 SourceLocation NameLoc,
13319 EnumDecl *ED) {
13320 bool Invalid = false;
13321
13323 /// In class scope, check if this is a duplicate, for better a diagnostic.
13324 DeclarationNameInfo UsingEnumName(ED->getDeclName(), NameLoc);
13325 LookupResult Previous(*this, UsingEnumName, LookupUsingDeclName,
13326 RedeclarationKind::ForVisibleRedeclaration);
13327
13329
13330 for (NamedDecl *D : Previous)
13331 if (UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(D))
13332 if (UED->getEnumDecl() == ED) {
13333 Diag(UsingLoc, diag::err_using_enum_decl_redeclaration)
13334 << SourceRange(EnumLoc, NameLoc);
13335 Diag(D->getLocation(), diag::note_using_enum_decl) << 1;
13336 Invalid = true;
13337 break;
13338 }
13339 }
13340
13341 if (RequireCompleteEnumDecl(ED, NameLoc))
13342 Invalid = true;
13343
13345 EnumLoc, NameLoc, EnumType);
13346 UD->setAccess(AS);
13347 CurContext->addDecl(UD);
13348
13349 if (Invalid) {
13350 UD->setInvalidDecl();
13351 return UD;
13352 }
13353
13354 // Create the shadow decls for each enumerator
13355 for (EnumConstantDecl *EC : ED->enumerators()) {
13356 UsingShadowDecl *PrevDecl = nullptr;
13357 DeclarationNameInfo DNI(EC->getDeclName(), EC->getLocation());
13359 RedeclarationKind::ForVisibleRedeclaration);
13360 LookupName(Previous, S);
13362
13363 if (!CheckUsingShadowDecl(UD, EC, Previous, PrevDecl))
13364 BuildUsingShadowDecl(S, UD, EC, PrevDecl);
13365 }
13366
13367 return UD;
13368}
13369
13371 ArrayRef<NamedDecl *> Expansions) {
13372 assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
13373 isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
13374 isa<UsingPackDecl>(InstantiatedFrom));
13375
13376 auto *UPD =
13377 UsingPackDecl::Create(Context, CurContext, InstantiatedFrom, Expansions);
13378 UPD->setAccess(InstantiatedFrom->getAccess());
13379 CurContext->addDecl(UPD);
13380 return UPD;
13381}
13382
13384 assert(!UD->hasTypename() && "expecting a constructor name");
13385
13386 QualType SourceType(UD->getQualifier().getAsType(), 0);
13387 CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
13388
13389 // Check whether the named type is a direct base class.
13390 bool AnyDependentBases = false;
13391 auto *Base =
13392 findDirectBaseWithType(TargetClass, SourceType, AnyDependentBases);
13393 if (!Base && !AnyDependentBases) {
13394 Diag(UD->getUsingLoc(), diag::err_using_decl_constructor_not_in_direct_base)
13395 << UD->getNameInfo().getSourceRange() << SourceType << TargetClass;
13396 UD->setInvalidDecl();
13397 return true;
13398 }
13399
13400 if (Base)
13401 Base->setInheritConstructors();
13402
13403 return false;
13404}
13405
13407 bool HasTypenameKeyword,
13408 const CXXScopeSpec &SS,
13409 SourceLocation NameLoc,
13410 const LookupResult &Prev) {
13411 NestedNameSpecifier Qual = SS.getScopeRep();
13412
13413 // C++03 [namespace.udecl]p8:
13414 // C++0x [namespace.udecl]p10:
13415 // A using-declaration is a declaration and can therefore be used
13416 // repeatedly where (and only where) multiple declarations are
13417 // allowed.
13418 //
13419 // That's in non-member contexts.
13421 // A dependent qualifier outside a class can only ever resolve to an
13422 // enumeration type. Therefore it conflicts with any other non-type
13423 // declaration in the same scope.
13424 // FIXME: How should we check for dependent type-type conflicts at block
13425 // scope?
13426 if (Qual.isDependent() && !HasTypenameKeyword) {
13427 for (auto *D : Prev) {
13428 if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
13429 bool OldCouldBeEnumerator =
13430 isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
13431 Diag(NameLoc,
13432 OldCouldBeEnumerator ? diag::err_redefinition
13433 : diag::err_redefinition_different_kind)
13434 << Prev.getLookupName();
13435 Diag(D->getLocation(), diag::note_previous_definition);
13436 return true;
13437 }
13438 }
13439 }
13440 return false;
13441 }
13442
13443 NestedNameSpecifier CNNS = Qual.getCanonical();
13444 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
13445 NamedDecl *D = *I;
13446
13447 bool DTypename;
13448 NestedNameSpecifier DQual = std::nullopt;
13449 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
13450 DTypename = UD->hasTypename();
13451 DQual = UD->getQualifier();
13452 } else if (UnresolvedUsingValueDecl *UD
13453 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
13454 DTypename = false;
13455 DQual = UD->getQualifier();
13456 } else if (UnresolvedUsingTypenameDecl *UD
13457 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
13458 DTypename = true;
13459 DQual = UD->getQualifier();
13460 } else continue;
13461
13462 // using decls differ if one says 'typename' and the other doesn't.
13463 // FIXME: non-dependent using decls?
13464 if (HasTypenameKeyword != DTypename) continue;
13465
13466 // using decls differ if they name different scopes (but note that
13467 // template instantiation can cause this check to trigger when it
13468 // didn't before instantiation).
13469 if (CNNS != DQual.getCanonical())
13470 continue;
13471
13472 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
13473 Diag(D->getLocation(), diag::note_using_decl) << 1;
13474 return true;
13475 }
13476
13477 return false;
13478}
13479
13480bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename,
13481 const CXXScopeSpec &SS,
13482 const DeclarationNameInfo &NameInfo,
13483 SourceLocation NameLoc,
13484 const LookupResult *R, const UsingDecl *UD) {
13485 DeclContext *NamedContext = computeDeclContext(SS);
13486 assert(bool(NamedContext) == (R || UD) && !(R && UD) &&
13487 "resolvable context must have exactly one set of decls");
13488
13489 // C++ 20 permits using an enumerator that does not have a class-hierarchy
13490 // relationship.
13491 bool Cxx20Enumerator = false;
13492 if (NamedContext) {
13493 EnumConstantDecl *EC = nullptr;
13494 if (R)
13495 EC = R->getAsSingle<EnumConstantDecl>();
13496 else if (UD && UD->shadow_size() == 1)
13497 EC = dyn_cast<EnumConstantDecl>(UD->shadow_begin()->getTargetDecl());
13498 if (EC)
13499 Cxx20Enumerator = getLangOpts().CPlusPlus20;
13500
13501 if (auto *ED = dyn_cast<EnumDecl>(NamedContext)) {
13502 // C++14 [namespace.udecl]p7:
13503 // A using-declaration shall not name a scoped enumerator.
13504 // C++20 p1099 permits enumerators.
13505 if (EC && R && ED->isScoped())
13506 Diag(SS.getBeginLoc(),
13508 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator
13509 : diag::ext_using_decl_scoped_enumerator)
13510 << SS.getRange();
13511
13512 // We want to consider the scope of the enumerator
13513 NamedContext = ED->getDeclContext();
13514 }
13515 }
13516
13517 if (!CurContext->isRecord()) {
13518 // C++03 [namespace.udecl]p3:
13519 // C++0x [namespace.udecl]p8:
13520 // A using-declaration for a class member shall be a member-declaration.
13521 // C++20 [namespace.udecl]p7
13522 // ... other than an enumerator ...
13523
13524 // If we weren't able to compute a valid scope, it might validly be a
13525 // dependent class or enumeration scope. If we have a 'typename' keyword,
13526 // the scope must resolve to a class type.
13527 if (NamedContext ? !NamedContext->getRedeclContext()->isRecord()
13528 : !HasTypename)
13529 return false; // OK
13530
13531 Diag(NameLoc,
13532 Cxx20Enumerator
13533 ? diag::warn_cxx17_compat_using_decl_class_member_enumerator
13534 : diag::err_using_decl_can_not_refer_to_class_member)
13535 << SS.getRange();
13536
13537 if (Cxx20Enumerator)
13538 return false; // OK
13539
13540 auto *RD = NamedContext
13541 ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
13542 : nullptr;
13543 if (RD && !RequireCompleteDeclContext(const_cast<CXXScopeSpec &>(SS), RD)) {
13544 // See if there's a helpful fixit
13545
13546 if (!R) {
13547 // We will have already diagnosed the problem on the template
13548 // definition, Maybe we should do so again?
13549 } else if (R->getAsSingle<TypeDecl>()) {
13550 if (getLangOpts().CPlusPlus11) {
13551 // Convert 'using X::Y;' to 'using Y = X::Y;'.
13552 Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
13553 << diag::MemClassWorkaround::AliasDecl
13555 NameInfo.getName().getAsString() +
13556 " = ");
13557 } else {
13558 // Convert 'using X::Y;' to 'typedef X::Y Y;'.
13559 SourceLocation InsertLoc = getLocForEndOfToken(NameInfo.getEndLoc());
13560 Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
13561 << diag::MemClassWorkaround::TypedefDecl
13562 << FixItHint::CreateReplacement(UsingLoc, "typedef")
13564 InsertLoc, " " + NameInfo.getName().getAsString());
13565 }
13566 } else if (R->getAsSingle<VarDecl>()) {
13567 // Don't provide a fixit outside C++11 mode; we don't want to suggest
13568 // repeating the type of the static data member here.
13569 FixItHint FixIt;
13570 if (getLangOpts().CPlusPlus11) {
13571 // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
13573 UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
13574 }
13575
13576 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13577 << diag::MemClassWorkaround::ReferenceDecl << FixIt;
13578 } else if (R->getAsSingle<EnumConstantDecl>()) {
13579 // Don't provide a fixit outside C++11 mode; we don't want to suggest
13580 // repeating the type of the enumeration here, and we can't do so if
13581 // the type is anonymous.
13582 FixItHint FixIt;
13583 if (getLangOpts().CPlusPlus11) {
13584 // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
13586 UsingLoc,
13587 "constexpr auto " + NameInfo.getName().getAsString() + " = ");
13588 }
13589
13590 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13591 << (getLangOpts().CPlusPlus11
13592 ? diag::MemClassWorkaround::ConstexprVar
13593 : diag::MemClassWorkaround::ConstVar)
13594 << FixIt;
13595 }
13596 }
13597
13598 return true; // Fail
13599 }
13600
13601 // If the named context is dependent, we can't decide much.
13602 if (!NamedContext) {
13603 // FIXME: in C++0x, we can diagnose if we can prove that the
13604 // nested-name-specifier does not refer to a base class, which is
13605 // still possible in some cases.
13606
13607 // Otherwise we have to conservatively report that things might be
13608 // okay.
13609 return false;
13610 }
13611
13612 // The current scope is a record.
13613 if (!NamedContext->isRecord()) {
13614 // Ideally this would point at the last name in the specifier,
13615 // but we don't have that level of source info.
13616 Diag(SS.getBeginLoc(),
13617 Cxx20Enumerator
13618 ? diag::warn_cxx17_compat_using_decl_non_member_enumerator
13619 : diag::err_using_decl_nested_name_specifier_is_not_class)
13620 << SS.getScopeRep() << SS.getRange();
13621
13622 if (Cxx20Enumerator)
13623 return false; // OK
13624
13625 return true;
13626 }
13627
13628 if (!NamedContext->isDependentContext() &&
13629 RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
13630 return true;
13631
13632 // C++26 [namespace.udecl]p3:
13633 // In a using-declaration used as a member-declaration, each
13634 // using-declarator shall either name an enumerator or have a
13635 // nested-name-specifier naming a base class of the current class
13636 // ([expr.prim.this]). ...
13637 // "have a nested-name-specifier naming a base class of the current class"
13638 // was introduced by CWG400.
13639
13640 if (cast<CXXRecordDecl>(CurContext)
13641 ->isProvablyNotDerivedFrom(cast<CXXRecordDecl>(NamedContext))) {
13642
13643 if (Cxx20Enumerator) {
13644 Diag(NameLoc, diag::warn_cxx17_compat_using_decl_non_member_enumerator)
13645 << SS.getRange();
13646 return false;
13647 }
13648
13649 if (CurContext == NamedContext) {
13650 Diag(SS.getBeginLoc(),
13651 diag::err_using_decl_nested_name_specifier_is_current_class)
13652 << SS.getRange();
13653 return true;
13654 }
13655
13656 if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
13657 Diag(SS.getBeginLoc(),
13658 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13659 << SS.getScopeRep() << cast<CXXRecordDecl>(CurContext)
13660 << SS.getRange();
13661 }
13662 return true;
13663 }
13664
13665 return false;
13666}
13667
13669 MultiTemplateParamsArg TemplateParamLists,
13670 SourceLocation UsingLoc, UnqualifiedId &Name,
13671 const ParsedAttributesView &AttrList,
13672 TypeResult Type, Decl *DeclFromDeclSpec) {
13673
13674 if (Type.isInvalid())
13675 return nullptr;
13676
13677 bool Invalid = false;
13679 TypeSourceInfo *TInfo = nullptr;
13680 GetTypeFromParser(Type.get(), &TInfo);
13681
13682 if (DiagnoseClassNameShadow(CurContext, NameInfo))
13683 return nullptr;
13684
13685 if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
13687 Invalid = true;
13689 TInfo->getTypeLoc().getBeginLoc());
13690 }
13691
13692 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
13693 TemplateParamLists.size()
13695 : RedeclarationKind::ForVisibleRedeclaration);
13696 LookupName(Previous, S);
13697
13698 // Warn about shadowing the name of a template parameter.
13699 if (Previous.isSingleResult() &&
13700 Previous.getFoundDecl()->isTemplateParameter()) {
13701 DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
13702 Previous.clear();
13703 }
13704
13705 assert(Name.getKind() == UnqualifiedIdKind::IK_Identifier &&
13706 "name in alias declaration must be an identifier");
13708 Name.StartLocation,
13709 Name.Identifier, TInfo);
13710
13711 NewTD->setAccess(AS);
13712
13713 if (Invalid)
13714 NewTD->setInvalidDecl();
13715
13716 ProcessDeclAttributeList(S, NewTD, AttrList);
13717 AddPragmaAttributes(S, NewTD);
13718 ProcessAPINotes(NewTD);
13719
13721 Invalid |= NewTD->isInvalidDecl();
13722
13723 // Get the innermost enclosing declaration scope.
13724 S = S->getDeclParent();
13725
13726 bool Redeclaration = false;
13727
13728 NamedDecl *NewND;
13729 if (TemplateParamLists.size()) {
13730 TypeAliasTemplateDecl *OldDecl = nullptr;
13731 TemplateParameterList *OldTemplateParams = nullptr;
13732
13733 if (TemplateParamLists.size() != 1) {
13734 Diag(UsingLoc, diag::err_alias_template_extra_headers)
13735 << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
13736 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13737 Invalid = true;
13738 }
13739 TemplateParameterList *TemplateParams = TemplateParamLists[0];
13740
13741 // Check that we can declare a template here.
13742 if (CheckTemplateDeclScope(S, TemplateParams))
13743 return nullptr;
13744
13745 // Only consider previous declarations in the same scope.
13746 FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
13747 /*ExplicitInstantiationOrSpecialization*/false);
13748 if (!Previous.empty()) {
13749 Redeclaration = true;
13750
13751 OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
13752 if (!OldDecl && !Invalid) {
13753 Diag(UsingLoc, diag::err_redefinition_different_kind)
13754 << Name.Identifier;
13755
13756 NamedDecl *OldD = Previous.getRepresentativeDecl();
13757 if (OldD->getLocation().isValid())
13758 Diag(OldD->getLocation(), diag::note_previous_definition);
13759
13760 Invalid = true;
13761 }
13762
13763 if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
13764 if (TemplateParameterListsAreEqual(TemplateParams,
13765 OldDecl->getTemplateParameters(),
13766 /*Complain=*/true,
13768 OldTemplateParams =
13770 else
13771 Invalid = true;
13772
13773 TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
13774 if (!Invalid &&
13776 NewTD->getUnderlyingType())) {
13777 // FIXME: The C++0x standard does not clearly say this is ill-formed,
13778 // but we can't reasonably accept it.
13779 Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
13780 << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
13781 if (OldTD->getLocation().isValid())
13782 Diag(OldTD->getLocation(), diag::note_previous_definition);
13783 Invalid = true;
13784 }
13785 }
13786 }
13787
13788 // Merge any previous default template arguments into our parameters,
13789 // and check the parameter list.
13790 if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
13791 TPC_Other))
13792 return nullptr;
13793
13794 TypeAliasTemplateDecl *NewDecl =
13796 Name.Identifier, TemplateParams,
13797 NewTD);
13798 NewTD->setDescribedAliasTemplate(NewDecl);
13799
13800 NewDecl->setAccess(AS);
13801
13802 if (Invalid)
13803 NewDecl->setInvalidDecl();
13804 else if (OldDecl) {
13805 NewDecl->setPreviousDecl(OldDecl);
13806 CheckRedeclarationInModule(NewDecl, OldDecl);
13807 }
13808
13809 NewND = NewDecl;
13810 } else {
13811 if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
13813 handleTagNumbering(TD, S);
13814 }
13816 NewND = NewTD;
13817 }
13818
13819 PushOnScopeChains(NewND, S);
13820 ActOnDocumentableDecl(NewND);
13821 return NewND;
13822}
13823
13825 SourceLocation AliasLoc,
13826 IdentifierInfo *Alias, CXXScopeSpec &SS,
13827 SourceLocation IdentLoc,
13828 IdentifierInfo *Ident) {
13829
13830 // Lookup the namespace name.
13831 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
13832 LookupParsedName(R, S, &SS, /*ObjectType=*/QualType());
13833
13834 if (R.isAmbiguous())
13835 return nullptr;
13836
13837 if (R.empty()) {
13838 if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
13839 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
13840 return nullptr;
13841 }
13842 }
13843 assert(!R.isAmbiguous() && !R.empty());
13844 auto *ND = cast<NamespaceBaseDecl>(R.getRepresentativeDecl());
13845
13846 // Check if we have a previous declaration with the same name.
13847 LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
13848 RedeclarationKind::ForVisibleRedeclaration);
13849 LookupName(PrevR, S);
13850
13851 // Check we're not shadowing a template parameter.
13852 if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
13854 PrevR.clear();
13855 }
13856
13857 // Filter out any other lookup result from an enclosing scope.
13858 FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
13859 /*AllowInlineNamespace*/false);
13860
13861 // Find the previous declaration and check that we can redeclare it.
13862 NamespaceAliasDecl *Prev = nullptr;
13863 if (PrevR.isSingleResult()) {
13864 NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
13865 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
13866 // We already have an alias with the same name that points to the same
13867 // namespace; check that it matches.
13868 if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
13869 Prev = AD;
13870 } else if (isVisible(PrevDecl)) {
13871 Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
13872 << Alias;
13873 Diag(AD->getLocation(), diag::note_previous_namespace_alias)
13874 << AD->getNamespace();
13875 return nullptr;
13876 }
13877 } else if (isVisible(PrevDecl)) {
13878 unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
13879 ? diag::err_redefinition
13880 : diag::err_redefinition_different_kind;
13881 Diag(AliasLoc, DiagID) << Alias;
13882 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
13883 return nullptr;
13884 }
13885 }
13886
13887 // The use of a nested name specifier may trigger deprecation warnings.
13888 DiagnoseUseOfDecl(ND, IdentLoc);
13889
13891 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
13892 Alias, SS.getWithLocInContext(Context),
13893 IdentLoc, ND);
13894 if (Prev)
13895 AliasDecl->setPreviousDecl(Prev);
13896
13898 return AliasDecl;
13899}
13900
13901namespace {
13902struct SpecialMemberExceptionSpecInfo
13903 : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
13906
13907 SpecialMemberExceptionSpecInfo(Sema &S, CXXMethodDecl *MD,
13911 : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
13912
13913 bool visitBase(CXXBaseSpecifier *Base);
13914 bool visitField(FieldDecl *FD);
13915
13916 void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
13917 unsigned Quals);
13918
13919 void visitSubobjectCall(Subobject Subobj,
13921};
13922}
13923
13924bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
13925 auto *BaseClass = Base->getType()->getAsCXXRecordDecl();
13926 if (!BaseClass)
13927 return false;
13928
13929 Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
13930 if (auto *BaseCtor = SMOR.getMethod()) {
13931 visitSubobjectCall(Base, BaseCtor);
13932 return false;
13933 }
13934
13935 visitClassSubobject(BaseClass, Base, 0);
13936 return false;
13937}
13938
13939bool SpecialMemberExceptionSpecInfo::visitField(FieldDecl *FD) {
13941 FD->hasInClassInitializer()) {
13942 Expr *E = FD->getInClassInitializer();
13943 if (!E)
13944 // FIXME: It's a little wasteful to build and throw away a
13945 // CXXDefaultInitExpr here.
13946 // FIXME: We should have a single context note pointing at Loc, and
13947 // this location should be MD->getLocation() instead, since that's
13948 // the location where we actually use the default init expression.
13949 E = S.BuildCXXDefaultInitExpr(Loc, FD).get();
13950 if (E)
13951 ExceptSpec.CalledExpr(E);
13952 } else if (auto *RD = S.Context.getBaseElementType(FD->getType())
13953 ->getAsCXXRecordDecl()) {
13954 visitClassSubobject(RD, FD, FD->getType().getCVRQualifiers());
13955 }
13956 return false;
13957}
13958
13959void SpecialMemberExceptionSpecInfo::visitClassSubobject(CXXRecordDecl *Class,
13960 Subobject Subobj,
13961 unsigned Quals) {
13962 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
13963 bool IsMutable = Field && Field->isMutable();
13964 visitSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable));
13965}
13966
13967void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
13968 Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR) {
13969 // Note, if lookup fails, it doesn't matter what exception specification we
13970 // choose because the special member will be deleted.
13971 if (CXXMethodDecl *MD = SMOR.getMethod())
13972 ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
13973}
13974
13976 llvm::APSInt Result;
13979 ExplicitSpec.setExpr(Converted.get());
13980 if (Converted.isUsable() && !Converted.get()->isValueDependent()) {
13981 ExplicitSpec.setKind(Result.getBoolValue()
13984 return true;
13985 }
13987 return false;
13988}
13989
13992 if (!ExplicitExpr->isTypeDependent())
13994 return ES;
13995}
13996
14001 ComputingExceptionSpec CES(S, MD, Loc);
14002
14003 CXXRecordDecl *ClassDecl = MD->getParent();
14004
14005 // C++ [except.spec]p14:
14006 // An implicitly declared special member function (Clause 12) shall have an
14007 // exception-specification. [...]
14008 SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->getLocation());
14009 if (ClassDecl->isInvalidDecl())
14010 return Info.ExceptSpec;
14011
14012 // FIXME: If this diagnostic fires, we're probably missing a check for
14013 // attempting to resolve an exception specification before it's known
14014 // at a higher level.
14015 if (S.RequireCompleteType(MD->getLocation(),
14016 S.Context.getCanonicalTagType(ClassDecl),
14017 diag::err_exception_spec_incomplete_type))
14018 return Info.ExceptSpec;
14019
14020 // C++1z [except.spec]p7:
14021 // [Look for exceptions thrown by] a constructor selected [...] to
14022 // initialize a potentially constructed subobject,
14023 // C++1z [except.spec]p8:
14024 // The exception specification for an implicitly-declared destructor, or a
14025 // destructor without a noexcept-specifier, is potentially-throwing if and
14026 // only if any of the destructors for any of its potentially constructed
14027 // subojects is potentially throwing.
14028 // FIXME: We respect the first rule but ignore the "potentially constructed"
14029 // in the second rule to resolve a core issue (no number yet) that would have
14030 // us reject:
14031 // struct A { virtual void f() = 0; virtual ~A() noexcept(false) = 0; };
14032 // struct B : A {};
14033 // struct C : B { void f(); };
14034 // ... due to giving B::~B() a non-throwing exception specification.
14035 Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
14036 : Info.VisitAllBases);
14037
14038 return Info.ExceptSpec;
14039}
14040
14041namespace {
14042/// RAII object to register a special member as being currently declared.
14043struct DeclaringSpecialMember {
14044 Sema &S;
14046 Sema::ContextRAII SavedContext;
14047 bool WasAlreadyBeingDeclared;
14048
14049 DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM)
14050 : S(S), D(RD, CSM), SavedContext(S, RD) {
14051 WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
14052 if (WasAlreadyBeingDeclared)
14053 // This almost never happens, but if it does, ensure that our cache
14054 // doesn't contain a stale result.
14055 S.SpecialMemberCache.clear();
14056 else {
14057 // Register a note to be produced if we encounter an error while
14058 // declaring the special member.
14061 // FIXME: We don't have a location to use here. Using the class's
14062 // location maintains the fiction that we declare all special members
14063 // with the class, but (1) it's not clear that lying about that helps our
14064 // users understand what's going on, and (2) there may be outer contexts
14065 // on the stack (some of which are relevant) and printing them exposes
14066 // our lies.
14067 Ctx.PointOfInstantiation = RD->getLocation();
14068 Ctx.Entity = RD;
14069 Ctx.SpecialMember = CSM;
14071 }
14072 }
14073 ~DeclaringSpecialMember() {
14074 if (!WasAlreadyBeingDeclared) {
14077 }
14078 }
14079
14080 /// Are we already trying to declare this special member?
14081 bool isAlreadyBeingDeclared() const {
14082 return WasAlreadyBeingDeclared;
14083 }
14084};
14085}
14086
14088 // Look up any existing declarations, but don't trigger declaration of all
14089 // implicit special members with this name.
14090 DeclarationName Name = FD->getDeclName();
14092 RedeclarationKind::ForExternalRedeclaration);
14093 for (auto *D : FD->getParent()->lookup(Name))
14094 if (auto *Acceptable = R.getAcceptableDecl(D))
14095 R.addDecl(Acceptable);
14096 R.resolveKind();
14098
14099 CheckFunctionDeclaration(S, FD, R, /*IsMemberSpecialization*/ false,
14101}
14102
14103void Sema::setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
14104 QualType ResultTy,
14105 ArrayRef<QualType> Args) {
14106 // Build an exception specification pointing back at this constructor.
14108
14110 if (AS != LangAS::Default) {
14111 EPI.TypeQuals.addAddressSpace(AS);
14112 }
14113
14114 auto QT = Context.getFunctionType(ResultTy, Args, EPI);
14115 SpecialMem->setType(QT);
14116
14117 // During template instantiation of implicit special member functions we need
14118 // a reliable TypeSourceInfo for the function prototype in order to allow
14119 // functions to be substituted.
14120 if (inTemplateInstantiation() && isLambdaMethod(SpecialMem)) {
14121 TypeSourceInfo *TSI =
14123 SpecialMem->setTypeSourceInfo(TSI);
14124 }
14125}
14126
14128 CXXRecordDecl *ClassDecl) {
14129 // C++ [class.ctor]p5:
14130 // A default constructor for a class X is a constructor of class X
14131 // that can be called without an argument. If there is no
14132 // user-declared constructor for class X, a default constructor is
14133 // implicitly declared. An implicitly-declared default constructor
14134 // is an inline public member of its class.
14135 assert(ClassDecl->needsImplicitDefaultConstructor() &&
14136 "Should not build implicit default constructor!");
14137
14138 DeclaringSpecialMember DSM(*this, ClassDecl,
14140 if (DSM.isAlreadyBeingDeclared())
14141 return nullptr;
14142
14144 *this, ClassDecl, CXXSpecialMemberKind::DefaultConstructor, false);
14145
14146 // Create the actual constructor declaration.
14147 CanQualType ClassType = Context.getCanonicalTagType(ClassDecl);
14148 SourceLocation ClassLoc = ClassDecl->getLocation();
14149 DeclarationName Name
14151 DeclarationNameInfo NameInfo(Name, ClassLoc);
14153 Context, ClassDecl, ClassLoc, NameInfo, /*Type*/ QualType(),
14154 /*TInfo=*/nullptr, ExplicitSpecifier(),
14155 getCurFPFeatures().isFPConstrained(),
14156 /*isInline=*/true, /*isImplicitlyDeclared=*/true,
14159 DefaultCon->setAccess(AS_public);
14160 DefaultCon->setDefaulted();
14161
14162 setupImplicitSpecialMemberType(DefaultCon, Context.VoidTy, {});
14163
14164 if (getLangOpts().CUDA)
14166 ClassDecl, CXXSpecialMemberKind::DefaultConstructor, DefaultCon,
14167 /* ConstRHS */ false,
14168 /* Diagnose */ false);
14169
14170 // We don't need to use SpecialMemberIsTrivial here; triviality for default
14171 // constructors is easy to compute.
14172 DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
14173
14174 // Note that we have declared this constructor.
14176
14177 Scope *S = getScopeForContext(ClassDecl);
14179
14180 if (ShouldDeleteSpecialMember(DefaultCon,
14182 SetDeclDeleted(DefaultCon, ClassLoc);
14183
14184 if (S)
14185 PushOnScopeChains(DefaultCon, S, false);
14186 ClassDecl->addDecl(DefaultCon);
14187
14188 return DefaultCon;
14189}
14190
14193 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
14194 !Constructor->doesThisDeclarationHaveABody() &&
14195 !Constructor->isDeleted()) &&
14196 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
14197 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14198 return;
14199
14200 CXXRecordDecl *ClassDecl = Constructor->getParent();
14201 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
14202 if (ClassDecl->isInvalidDecl()) {
14203 return;
14204 }
14205
14207
14208 // The exception specification is needed because we are defining the
14209 // function.
14210 ResolveExceptionSpec(CurrentLocation,
14211 Constructor->getType()->castAs<FunctionProtoType>());
14212 MarkVTableUsed(CurrentLocation, ClassDecl);
14213
14214 // Add a context note for diagnostics produced after this point.
14215 Scope.addContextNote(CurrentLocation);
14216
14217 if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
14218 Constructor->setInvalidDecl();
14219 return;
14220 }
14221
14222 SourceLocation Loc = Constructor->getEndLoc().isValid()
14223 ? Constructor->getEndLoc()
14224 : Constructor->getLocation();
14225 Constructor->setBody(new (Context) CompoundStmt(Loc));
14226 Constructor->markUsed(Context);
14227
14229 L->CompletedImplicitDefinition(Constructor);
14230 }
14231
14232 DiagnoseUninitializedFields(*this, Constructor);
14233}
14234
14236 // Perform any delayed checks on exception specifications.
14238}
14239
14240/// Find or create the fake constructor we synthesize to model constructing an
14241/// object of a derived class via a constructor of a base class.
14244 CXXConstructorDecl *BaseCtor,
14246 CXXRecordDecl *Derived = Shadow->getParent();
14247 SourceLocation UsingLoc = Shadow->getLocation();
14248
14249 // FIXME: Add a new kind of DeclarationName for an inherited constructor.
14250 // For now we use the name of the base class constructor as a member of the
14251 // derived class to indicate a (fake) inherited constructor name.
14252 DeclarationName Name = BaseCtor->getDeclName();
14253
14254 // Check to see if we already have a fake constructor for this inherited
14255 // constructor call.
14256 for (NamedDecl *Ctor : Derived->lookup(Name))
14257 if (declaresSameEntity(cast<CXXConstructorDecl>(Ctor)
14258 ->getInheritedConstructor()
14259 .getConstructor(),
14260 BaseCtor))
14261 return cast<CXXConstructorDecl>(Ctor);
14262
14263 DeclarationNameInfo NameInfo(Name, UsingLoc);
14264 TypeSourceInfo *TInfo =
14265 Context.getTrivialTypeSourceInfo(BaseCtor->getType(), UsingLoc);
14266 FunctionProtoTypeLoc ProtoLoc =
14268
14269 // Check the inherited constructor is valid and find the list of base classes
14270 // from which it was inherited.
14271 InheritedConstructorInfo ICI(*this, Loc, Shadow);
14272
14273 bool Constexpr = BaseCtor->isConstexpr() &&
14276 false, BaseCtor, &ICI);
14277
14279 Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
14280 BaseCtor->getExplicitSpecifier(), getCurFPFeatures().isFPConstrained(),
14281 /*isInline=*/true,
14282 /*isImplicitlyDeclared=*/true,
14284 InheritedConstructor(Shadow, BaseCtor),
14285 BaseCtor->getTrailingRequiresClause());
14286 if (Shadow->isInvalidDecl())
14287 DerivedCtor->setInvalidDecl();
14288
14289 // Build an unevaluated exception specification for this fake constructor.
14290 const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
14293 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
14294 DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
14295 FPT->getParamTypes(), EPI));
14296
14297 // Build the parameter declarations.
14299 for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
14300 TypeSourceInfo *TInfo =
14303 Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
14304 FPT->getParamType(I), TInfo, SC_None, /*DefArg=*/nullptr);
14305 PD->setScopeInfo(0, I);
14306 PD->setImplicit();
14307 // Ensure attributes are propagated onto parameters (this matters for
14308 // format, pass_object_size, ...).
14309 mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
14310 ParamDecls.push_back(PD);
14311 ProtoLoc.setParam(I, PD);
14312 }
14313
14314 // Set up the new constructor.
14315 assert(!BaseCtor->isDeleted() && "should not use deleted constructor");
14316 DerivedCtor->setAccess(BaseCtor->getAccess());
14317 DerivedCtor->setParams(ParamDecls);
14318 Derived->addDecl(DerivedCtor);
14319
14320 if (ShouldDeleteSpecialMember(DerivedCtor,
14322 SetDeclDeleted(DerivedCtor, UsingLoc);
14323
14324 return DerivedCtor;
14325}
14326
14328 InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
14331 &ICI,
14332 /*Diagnose*/ true);
14333}
14334
14337 CXXRecordDecl *ClassDecl = Constructor->getParent();
14338 assert(Constructor->getInheritedConstructor() &&
14339 !Constructor->doesThisDeclarationHaveABody() &&
14340 !Constructor->isDeleted());
14341 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14342 return;
14343
14344 // Initializations are performed "as if by a defaulted default constructor",
14345 // so enter the appropriate scope.
14347
14348 // The exception specification is needed because we are defining the
14349 // function.
14350 ResolveExceptionSpec(CurrentLocation,
14351 Constructor->getType()->castAs<FunctionProtoType>());
14352 MarkVTableUsed(CurrentLocation, ClassDecl);
14353
14354 // Add a context note for diagnostics produced after this point.
14355 Scope.addContextNote(CurrentLocation);
14356
14358 Constructor->getInheritedConstructor().getShadowDecl();
14359 CXXConstructorDecl *InheritedCtor =
14360 Constructor->getInheritedConstructor().getConstructor();
14361
14362 // [class.inhctor.init]p1:
14363 // initialization proceeds as if a defaulted default constructor is used to
14364 // initialize the D object and each base class subobject from which the
14365 // constructor was inherited
14366
14367 InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
14368 CXXRecordDecl *RD = Shadow->getParent();
14369 SourceLocation InitLoc = Shadow->getLocation();
14370
14371 // Build explicit initializers for all base classes from which the
14372 // constructor was inherited.
14374 for (bool VBase : {false, true}) {
14375 for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
14376 if (B.isVirtual() != VBase)
14377 continue;
14378
14379 auto *BaseRD = B.getType()->getAsCXXRecordDecl();
14380 if (!BaseRD)
14381 continue;
14382
14383 auto BaseCtor = ICI.findConstructorForBase(BaseRD, InheritedCtor);
14384 if (!BaseCtor.first)
14385 continue;
14386
14387 MarkFunctionReferenced(CurrentLocation, BaseCtor.first);
14389 InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
14390
14391 auto *TInfo = Context.getTrivialTypeSourceInfo(B.getType(), InitLoc);
14392 Inits.push_back(new (Context) CXXCtorInitializer(
14393 Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
14394 SourceLocation()));
14395 }
14396 }
14397
14398 // We now proceed as if for a defaulted default constructor, with the relevant
14399 // initializers replaced.
14400
14401 if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits)) {
14402 Constructor->setInvalidDecl();
14403 return;
14404 }
14405
14406 Constructor->setBody(new (Context) CompoundStmt(InitLoc));
14407 Constructor->markUsed(Context);
14408
14410 L->CompletedImplicitDefinition(Constructor);
14411 }
14412
14413 DiagnoseUninitializedFields(*this, Constructor);
14414}
14415
14417 // C++ [class.dtor]p2:
14418 // If a class has no user-declared destructor, a destructor is
14419 // declared implicitly. An implicitly-declared destructor is an
14420 // inline public member of its class.
14421 assert(ClassDecl->needsImplicitDestructor());
14422
14423 DeclaringSpecialMember DSM(*this, ClassDecl,
14425 if (DSM.isAlreadyBeingDeclared())
14426 return nullptr;
14427
14429 *this, ClassDecl, CXXSpecialMemberKind::Destructor, false);
14430
14431 // Create the actual destructor declaration.
14432 CanQualType ClassType = Context.getCanonicalTagType(ClassDecl);
14433 SourceLocation ClassLoc = ClassDecl->getLocation();
14434 DeclarationName Name
14436 DeclarationNameInfo NameInfo(Name, ClassLoc);
14438 Context, ClassDecl, ClassLoc, NameInfo, QualType(), nullptr,
14439 getCurFPFeatures().isFPConstrained(),
14440 /*isInline=*/true,
14441 /*isImplicitlyDeclared=*/true,
14444 Destructor->setAccess(AS_public);
14445 Destructor->setDefaulted();
14446
14447 setupImplicitSpecialMemberType(Destructor, Context.VoidTy, {});
14448
14449 if (getLangOpts().CUDA)
14452 /* ConstRHS */ false,
14453 /* Diagnose */ false);
14454
14455 // We don't need to use SpecialMemberIsTrivial here; triviality for
14456 // destructors is easy to compute.
14457 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
14458 Destructor->setTrivialForCall(ClassDecl->hasAttr<TrivialABIAttr>() ||
14459 ClassDecl->hasTrivialDestructorForCall());
14460
14461 // Note that we have declared this destructor.
14463
14464 Scope *S = getScopeForContext(ClassDecl);
14466
14467 // We can't check whether an implicit destructor is deleted before we complete
14468 // the definition of the class, because its validity depends on the alignment
14469 // of the class. We'll check this from ActOnFields once the class is complete.
14470 if (ClassDecl->isCompleteDefinition() &&
14472 SetDeclDeleted(Destructor, ClassLoc);
14473
14474 // Introduce this destructor into its scope.
14475 if (S)
14476 PushOnScopeChains(Destructor, S, false);
14477 ClassDecl->addDecl(Destructor);
14478
14479 return Destructor;
14480}
14481
14484 assert((Destructor->isDefaulted() &&
14485 !Destructor->doesThisDeclarationHaveABody() &&
14486 !Destructor->isDeleted()) &&
14487 "DefineImplicitDestructor - call it for implicit default dtor");
14488 if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
14489 return;
14490
14491 CXXRecordDecl *ClassDecl = Destructor->getParent();
14492 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
14493
14495
14496 // The exception specification is needed because we are defining the
14497 // function.
14498 ResolveExceptionSpec(CurrentLocation,
14499 Destructor->getType()->castAs<FunctionProtoType>());
14500 MarkVTableUsed(CurrentLocation, ClassDecl);
14501
14502 // Add a context note for diagnostics produced after this point.
14503 Scope.addContextNote(CurrentLocation);
14504
14506 Destructor->getParent());
14507
14509 Destructor->setInvalidDecl();
14510 return;
14511 }
14512
14513 SourceLocation Loc = Destructor->getEndLoc().isValid()
14514 ? Destructor->getEndLoc()
14515 : Destructor->getLocation();
14516 Destructor->setBody(new (Context) CompoundStmt(Loc));
14517 Destructor->markUsed(Context);
14518
14520 L->CompletedImplicitDefinition(Destructor);
14521 }
14522}
14523
14526 if (Destructor->isInvalidDecl())
14527 return;
14528
14529 CXXRecordDecl *ClassDecl = Destructor->getParent();
14531 "implicit complete dtors unneeded outside MS ABI");
14532 assert(ClassDecl->getNumVBases() > 0 &&
14533 "complete dtor only exists for classes with vbases");
14534
14536
14537 // Add a context note for diagnostics produced after this point.
14538 Scope.addContextNote(CurrentLocation);
14539
14540 MarkVirtualBaseDestructorsReferenced(Destructor->getLocation(), ClassDecl);
14541}
14542
14544 // If the context is an invalid C++ class, just suppress these checks.
14545 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
14546 if (Record->isInvalidDecl()) {
14549 return;
14550 }
14552 }
14553}
14554
14557
14558 if (!DelayedDllExportMemberFunctions.empty()) {
14560 std::swap(DelayedDllExportMemberFunctions, WorkList);
14561 for (CXXMethodDecl *M : WorkList) {
14562 DefineDefaultedFunction(*this, M, M->getLocation());
14563
14564 // Pass the method to the consumer to get emitted. This is not necessary
14565 // for explicit instantiation definitions, as they will get emitted
14566 // anyway.
14567 if (M->getParent()->getTemplateSpecializationKind() !=
14570 }
14571 }
14572}
14573
14575 if (!DelayedDllExportClasses.empty()) {
14576 // Calling ReferenceDllExportedMembers might cause the current function to
14577 // be called again, so use a local copy of DelayedDllExportClasses.
14579 std::swap(DelayedDllExportClasses, WorkList);
14580 for (CXXRecordDecl *Class : WorkList)
14582 }
14583}
14584
14586 assert(getLangOpts().CPlusPlus11 &&
14587 "adjusting dtor exception specs was introduced in c++11");
14588
14589 if (Destructor->isDependentContext())
14590 return;
14591
14592 // C++11 [class.dtor]p3:
14593 // A declaration of a destructor that does not have an exception-
14594 // specification is implicitly considered to have the same exception-
14595 // specification as an implicit declaration.
14596 const auto *DtorType = Destructor->getType()->castAs<FunctionProtoType>();
14597 if (DtorType->hasExceptionSpec())
14598 return;
14599
14600 // Replace the destructor's type, building off the existing one. Fortunately,
14601 // the only thing of interest in the destructor type is its extended info.
14602 // The return and arguments are fixed.
14603 FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
14606 Destructor->setType(Context.getFunctionType(Context.VoidTy, {}, EPI));
14607
14608 // FIXME: If the destructor has a body that could throw, and the newly created
14609 // spec doesn't allow exceptions, we should emit a warning, because this
14610 // change in behavior can break conforming C++03 programs at runtime.
14611 // However, we don't have a body or an exception specification yet, so it
14612 // needs to be done somewhere else.
14613}
14614
14615namespace {
14616/// An abstract base class for all helper classes used in building the
14617// copy/move operators. These classes serve as factory functions and help us
14618// avoid using the same Expr* in the AST twice.
14619class ExprBuilder {
14620 ExprBuilder(const ExprBuilder&) = delete;
14621 ExprBuilder &operator=(const ExprBuilder&) = delete;
14622
14623protected:
14624 static Expr *assertNotNull(Expr *E) {
14625 assert(E && "Expression construction must not fail.");
14626 return E;
14627 }
14628
14629public:
14630 ExprBuilder() {}
14631 virtual ~ExprBuilder() {}
14632
14633 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
14634};
14635
14636class RefBuilder: public ExprBuilder {
14637 VarDecl *Var;
14638 QualType VarType;
14639
14640public:
14641 Expr *build(Sema &S, SourceLocation Loc) const override {
14642 return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc));
14643 }
14644
14645 RefBuilder(VarDecl *Var, QualType VarType)
14646 : Var(Var), VarType(VarType) {}
14647};
14648
14649class ThisBuilder: public ExprBuilder {
14650public:
14651 Expr *build(Sema &S, SourceLocation Loc) const override {
14652 return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
14653 }
14654};
14655
14656class CastBuilder: public ExprBuilder {
14657 const ExprBuilder &Builder;
14658 QualType Type;
14660 const CXXCastPath &Path;
14661
14662public:
14663 Expr *build(Sema &S, SourceLocation Loc) const override {
14664 return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
14665 CK_UncheckedDerivedToBase, Kind,
14666 &Path).get());
14667 }
14668
14669 CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
14670 const CXXCastPath &Path)
14671 : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
14672};
14673
14674class DerefBuilder: public ExprBuilder {
14675 const ExprBuilder &Builder;
14676
14677public:
14678 Expr *build(Sema &S, SourceLocation Loc) const override {
14679 return assertNotNull(
14680 S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
14681 }
14682
14683 DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14684};
14685
14686class MemberBuilder: public ExprBuilder {
14687 const ExprBuilder &Builder;
14688 QualType Type;
14689 CXXScopeSpec SS;
14690 bool IsArrow;
14691 LookupResult &MemberLookup;
14692
14693public:
14694 Expr *build(Sema &S, SourceLocation Loc) const override {
14695 return assertNotNull(S.BuildMemberReferenceExpr(
14696 Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
14697 nullptr, MemberLookup, nullptr, nullptr).get());
14698 }
14699
14700 MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
14701 LookupResult &MemberLookup)
14702 : Builder(Builder), Type(Type), IsArrow(IsArrow),
14703 MemberLookup(MemberLookup) {}
14704};
14705
14706class MoveCastBuilder: public ExprBuilder {
14707 const ExprBuilder &Builder;
14708
14709public:
14710 Expr *build(Sema &S, SourceLocation Loc) const override {
14711 return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
14712 }
14713
14714 MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14715};
14716
14717class LvalueConvBuilder: public ExprBuilder {
14718 const ExprBuilder &Builder;
14719
14720public:
14721 Expr *build(Sema &S, SourceLocation Loc) const override {
14722 return assertNotNull(
14723 S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
14724 }
14725
14726 LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14727};
14728
14729class SubscriptBuilder: public ExprBuilder {
14730 const ExprBuilder &Base;
14731 const ExprBuilder &Index;
14732
14733public:
14734 Expr *build(Sema &S, SourceLocation Loc) const override {
14735 return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
14736 Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
14737 }
14738
14739 SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
14740 : Base(Base), Index(Index) {}
14741};
14742
14743} // end anonymous namespace
14744
14745/// When generating a defaulted copy or move assignment operator, if a field
14746/// should be copied with __builtin_memcpy rather than via explicit assignments,
14747/// do so. This optimization only applies for arrays of scalars, and for arrays
14748/// of class type where the selected copy/move-assignment operator is trivial.
14749static StmtResult
14751 const ExprBuilder &ToB, const ExprBuilder &FromB) {
14752 // Compute the size of the memory buffer to be copied.
14753 QualType SizeType = S.Context.getSizeType();
14754 llvm::APInt Size(S.Context.getTypeSize(SizeType),
14756
14757 // Take the address of the field references for "from" and "to". We
14758 // directly construct UnaryOperators here because semantic analysis
14759 // does not permit us to take the address of an xvalue.
14760 Expr *From = FromB.build(S, Loc);
14761 From = UnaryOperator::Create(
14762 S.Context, From, UO_AddrOf, S.Context.getPointerType(From->getType()),
14764 Expr *To = ToB.build(S, Loc);
14766 S.Context, To, UO_AddrOf, S.Context.getPointerType(To->getType()),
14768
14769 bool NeedsCollectableMemCpy = false;
14770 if (auto *RD = T->getBaseElementTypeUnsafe()->getAsRecordDecl())
14771 NeedsCollectableMemCpy = RD->hasObjectMember();
14772
14773 // Create a reference to the __builtin_objc_memmove_collectable function
14774 StringRef MemCpyName = NeedsCollectableMemCpy ?
14775 "__builtin_objc_memmove_collectable" :
14776 "__builtin_memcpy";
14777 LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
14779 S.LookupName(R, S.TUScope, true);
14780
14781 FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
14782 if (!MemCpy)
14783 // Something went horribly wrong earlier, and we will have complained
14784 // about it.
14785 return StmtError();
14786
14787 ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
14788 VK_PRValue, Loc, nullptr);
14789 assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
14790
14791 Expr *CallArgs[] = {
14792 To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
14793 };
14794 ExprResult Call = S.BuildCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
14795 Loc, CallArgs, Loc);
14796
14797 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
14798 return Call.getAs<Stmt>();
14799}
14800
14801/// Builds a statement that copies/moves the given entity from \p From to
14802/// \c To.
14803///
14804/// This routine is used to copy/move the members of a class with an
14805/// implicitly-declared copy/move assignment operator. When the entities being
14806/// copied are arrays, this routine builds for loops to copy them.
14807///
14808/// \param S The Sema object used for type-checking.
14809///
14810/// \param Loc The location where the implicit copy/move is being generated.
14811///
14812/// \param T The type of the expressions being copied/moved. Both expressions
14813/// must have this type.
14814///
14815/// \param To The expression we are copying/moving to.
14816///
14817/// \param From The expression we are copying/moving from.
14818///
14819/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
14820/// Otherwise, it's a non-static member subobject.
14821///
14822/// \param Copying Whether we're copying or moving.
14823///
14824/// \param Depth Internal parameter recording the depth of the recursion.
14825///
14826/// \returns A statement or a loop that copies the expressions, or StmtResult(0)
14827/// if a memcpy should be used instead.
14828static StmtResult
14830 const ExprBuilder &To, const ExprBuilder &From,
14831 bool CopyingBaseSubobject, bool Copying,
14832 unsigned Depth = 0) {
14833 // C++11 [class.copy]p28:
14834 // Each subobject is assigned in the manner appropriate to its type:
14835 //
14836 // - if the subobject is of class type, as if by a call to operator= with
14837 // the subobject as the object expression and the corresponding
14838 // subobject of x as a single function argument (as if by explicit
14839 // qualification; that is, ignoring any possible virtual overriding
14840 // functions in more derived classes);
14841 //
14842 // C++03 [class.copy]p13:
14843 // - if the subobject is of class type, the copy assignment operator for
14844 // the class is used (as if by explicit qualification; that is,
14845 // ignoring any possible virtual overriding functions in more derived
14846 // classes);
14847 if (auto *ClassDecl = T->getAsCXXRecordDecl()) {
14848 // Look for operator=.
14849 DeclarationName Name
14851 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
14852 S.LookupQualifiedName(OpLookup, ClassDecl, false);
14853
14854 // Prior to C++11, filter out any result that isn't a copy/move-assignment
14855 // operator.
14856 if (!S.getLangOpts().CPlusPlus11) {
14857 LookupResult::Filter F = OpLookup.makeFilter();
14858 while (F.hasNext()) {
14859 NamedDecl *D = F.next();
14860 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
14861 if (Method->isCopyAssignmentOperator() ||
14862 (!Copying && Method->isMoveAssignmentOperator()))
14863 continue;
14864
14865 F.erase();
14866 }
14867 F.done();
14868 }
14869
14870 // Suppress the protected check (C++ [class.protected]) for each of the
14871 // assignment operators we found. This strange dance is required when
14872 // we're assigning via a base classes's copy-assignment operator. To
14873 // ensure that we're getting the right base class subobject (without
14874 // ambiguities), we need to cast "this" to that subobject type; to
14875 // ensure that we don't go through the virtual call mechanism, we need
14876 // to qualify the operator= name with the base class (see below). However,
14877 // this means that if the base class has a protected copy assignment
14878 // operator, the protected member access check will fail. So, we
14879 // rewrite "protected" access to "public" access in this case, since we
14880 // know by construction that we're calling from a derived class.
14881 if (CopyingBaseSubobject) {
14882 for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
14883 L != LEnd; ++L) {
14884 if (L.getAccess() == AS_protected)
14885 L.setAccess(AS_public);
14886 }
14887 }
14888
14889 // Create the nested-name-specifier that will be used to qualify the
14890 // reference to operator=; this is required to suppress the virtual
14891 // call mechanism.
14892 CXXScopeSpec SS;
14893 // FIXME: Don't canonicalize this.
14894 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
14895 SS.MakeTrivial(S.Context, NestedNameSpecifier(CanonicalT), Loc);
14896
14897 // Create the reference to operator=.
14898 ExprResult OpEqualRef
14899 = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*IsArrow=*/false,
14900 SS, /*TemplateKWLoc=*/SourceLocation(),
14901 /*FirstQualifierInScope=*/nullptr,
14902 OpLookup,
14903 /*TemplateArgs=*/nullptr, /*S*/nullptr,
14904 /*SuppressQualifierCheck=*/true);
14905 if (OpEqualRef.isInvalid())
14906 return StmtError();
14907
14908 // Build the call to the assignment operator.
14909
14910 Expr *FromInst = From.build(S, Loc);
14911 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
14912 OpEqualRef.getAs<Expr>(),
14913 Loc, FromInst, Loc);
14914 if (Call.isInvalid())
14915 return StmtError();
14916
14917 // If we built a call to a trivial 'operator=' while copying an array,
14918 // bail out. We'll replace the whole shebang with a memcpy.
14919 CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
14920 if (CE && CE->getMethodDecl()->isTrivial() && Depth)
14921 return StmtResult((Stmt*)nullptr);
14922
14923 // Convert to an expression-statement, and clean up any produced
14924 // temporaries.
14925 return S.ActOnExprStmt(Call);
14926 }
14927
14928 // - if the subobject is of scalar type, the built-in assignment
14929 // operator is used.
14931 if (!ArrayTy) {
14933 Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
14934 if (Assignment.isInvalid())
14935 return StmtError();
14936 return S.ActOnExprStmt(Assignment);
14937 }
14938
14939 // - if the subobject is an array, each element is assigned, in the
14940 // manner appropriate to the element type;
14941
14942 // Construct a loop over the array bounds, e.g.,
14943 //
14944 // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
14945 //
14946 // that will copy each of the array elements.
14947 QualType SizeType = S.Context.getSizeType();
14948
14949 // Create the iteration variable.
14950 IdentifierInfo *IterationVarName = nullptr;
14951 {
14952 SmallString<8> Str;
14953 llvm::raw_svector_ostream OS(Str);
14954 OS << "__i" << Depth;
14955 IterationVarName = &S.Context.Idents.get(OS.str());
14956 }
14957 VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
14958 IterationVarName, SizeType,
14960 SC_None);
14961
14962 // Initialize the iteration variable to zero.
14963 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
14964 IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
14965
14966 // Creates a reference to the iteration variable.
14967 RefBuilder IterationVarRef(IterationVar, SizeType);
14968 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
14969
14970 // Create the DeclStmt that holds the iteration variable.
14971 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
14972
14973 // Subscript the "from" and "to" expressions with the iteration variable.
14974 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
14975 MoveCastBuilder FromIndexMove(FromIndexCopy);
14976 const ExprBuilder *FromIndex;
14977 if (Copying)
14978 FromIndex = &FromIndexCopy;
14979 else
14980 FromIndex = &FromIndexMove;
14981
14982 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
14983
14984 // Build the copy/move for an individual element of the array.
14987 ToIndex, *FromIndex, CopyingBaseSubobject,
14988 Copying, Depth + 1);
14989 // Bail out if copying fails or if we determined that we should use memcpy.
14990 if (Copy.isInvalid() || !Copy.get())
14991 return Copy;
14992
14993 // Create the comparison against the array bound.
14994 llvm::APInt Upper
14995 = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
14996 Expr *Comparison = BinaryOperator::Create(
14997 S.Context, IterationVarRefRVal.build(S, Loc),
14998 IntegerLiteral::Create(S.Context, Upper, SizeType, Loc), BO_NE,
15001
15002 // Create the pre-increment of the iteration variable. We can determine
15003 // whether the increment will overflow based on the value of the array
15004 // bound.
15005 Expr *Increment = UnaryOperator::Create(
15006 S.Context, IterationVarRef.build(S, Loc), UO_PreInc, SizeType, VK_LValue,
15007 OK_Ordinary, Loc, Upper.isMaxValue(), S.CurFPFeatureOverrides());
15008
15009 // Construct the loop that copies all elements of this array.
15010 return S.ActOnForStmt(
15011 Loc, Loc, InitStmt,
15012 S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
15013 S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
15014}
15015
15016static StmtResult
15018 const ExprBuilder &To, const ExprBuilder &From,
15019 bool CopyingBaseSubobject, bool Copying) {
15020 // Maybe we should use a memcpy?
15021 if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
15022 T.isTriviallyCopyableType(S.Context))
15023 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
15024
15026 CopyingBaseSubobject,
15027 Copying, 0));
15028
15029 // If we ended up picking a trivial assignment operator for an array of a
15030 // non-trivially-copyable class type, just emit a memcpy.
15031 if (!Result.isInvalid() && !Result.get())
15032 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
15033
15034 return Result;
15035}
15036
15038 // Note: The following rules are largely analoguous to the copy
15039 // constructor rules. Note that virtual bases are not taken into account
15040 // for determining the argument type of the operator. Note also that
15041 // operators taking an object instead of a reference are allowed.
15042 assert(ClassDecl->needsImplicitCopyAssignment());
15043
15044 DeclaringSpecialMember DSM(*this, ClassDecl,
15046 if (DSM.isAlreadyBeingDeclared())
15047 return nullptr;
15048
15050 /*Qualifier=*/std::nullopt, ClassDecl,
15051 /*OwnsTag=*/false);
15053 if (AS != LangAS::Default)
15054 ArgType = Context.getAddrSpaceQualType(ArgType, AS);
15055 QualType RetType = Context.getLValueReferenceType(ArgType);
15056 bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
15057 if (Const)
15058 ArgType = ArgType.withConst();
15059
15060 ArgType = Context.getLValueReferenceType(ArgType);
15061
15063 *this, ClassDecl, CXXSpecialMemberKind::CopyAssignment, Const);
15064
15065 // An implicitly-declared copy assignment operator is an inline public
15066 // member of its class.
15068 SourceLocation ClassLoc = ClassDecl->getLocation();
15069 DeclarationNameInfo NameInfo(Name, ClassLoc);
15071 Context, ClassDecl, ClassLoc, NameInfo, QualType(),
15072 /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
15073 getCurFPFeatures().isFPConstrained(),
15074 /*isInline=*/true,
15076 SourceLocation());
15077 CopyAssignment->setAccess(AS_public);
15078 CopyAssignment->setDefaulted();
15079 CopyAssignment->setImplicit();
15080
15081 setupImplicitSpecialMemberType(CopyAssignment, RetType, ArgType);
15082
15083 if (getLangOpts().CUDA)
15086 /* ConstRHS */ Const,
15087 /* Diagnose */ false);
15088
15089 // Add the parameter to the operator.
15091 ClassLoc, ClassLoc,
15092 /*Id=*/nullptr, ArgType,
15093 /*TInfo=*/nullptr, SC_None,
15094 nullptr);
15095 CopyAssignment->setParams(FromParam);
15096
15097 CopyAssignment->setTrivial(
15101 : ClassDecl->hasTrivialCopyAssignment());
15102
15103 // Note that we have added this copy-assignment operator.
15105
15106 Scope *S = getScopeForContext(ClassDecl);
15108
15112 SetDeclDeleted(CopyAssignment, ClassLoc);
15113 }
15114
15115 if (S)
15117 ClassDecl->addDecl(CopyAssignment);
15118
15119 return CopyAssignment;
15120}
15121
15122/// Diagnose an implicit copy operation for a class which is odr-used, but
15123/// which is deprecated because the class has a user-declared copy constructor,
15124/// copy assignment operator, or destructor.
15126 assert(CopyOp->isImplicit());
15127
15128 CXXRecordDecl *RD = CopyOp->getParent();
15129 CXXMethodDecl *UserDeclaredOperation = nullptr;
15130
15131 if (RD->hasUserDeclaredDestructor()) {
15132 UserDeclaredOperation = RD->getDestructor();
15133 } else if (!isa<CXXConstructorDecl>(CopyOp) &&
15135 // Find any user-declared copy constructor.
15136 for (auto *I : RD->ctors()) {
15137 if (I->isCopyConstructor()) {
15138 UserDeclaredOperation = I;
15139 break;
15140 }
15141 }
15142 assert(UserDeclaredOperation);
15143 } else if (isa<CXXConstructorDecl>(CopyOp) &&
15145 // Find any user-declared move assignment operator.
15146 for (auto *I : RD->methods()) {
15147 if (I->isCopyAssignmentOperator()) {
15148 UserDeclaredOperation = I;
15149 break;
15150 }
15151 }
15152 assert(UserDeclaredOperation);
15153 }
15154
15155 if (UserDeclaredOperation) {
15156 bool UDOIsUserProvided = UserDeclaredOperation->isUserProvided();
15157 bool UDOIsDestructor = isa<CXXDestructorDecl>(UserDeclaredOperation);
15158 bool IsCopyAssignment = !isa<CXXConstructorDecl>(CopyOp);
15159 unsigned DiagID =
15160 (UDOIsUserProvided && UDOIsDestructor)
15161 ? diag::warn_deprecated_copy_with_user_provided_dtor
15162 : (UDOIsUserProvided && !UDOIsDestructor)
15163 ? diag::warn_deprecated_copy_with_user_provided_copy
15164 : (!UDOIsUserProvided && UDOIsDestructor)
15165 ? diag::warn_deprecated_copy_with_dtor
15166 : diag::warn_deprecated_copy;
15167 S.Diag(UserDeclaredOperation->getLocation(), DiagID)
15168 << RD << IsCopyAssignment;
15169 }
15170}
15171
15173 CXXMethodDecl *CopyAssignOperator) {
15174 assert((CopyAssignOperator->isDefaulted() &&
15175 CopyAssignOperator->isOverloadedOperator() &&
15176 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
15177 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
15178 !CopyAssignOperator->isDeleted()) &&
15179 "DefineImplicitCopyAssignment called for wrong function");
15180 if (CopyAssignOperator->willHaveBody() || CopyAssignOperator->isInvalidDecl())
15181 return;
15182
15183 CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
15184 if (ClassDecl->isInvalidDecl()) {
15185 CopyAssignOperator->setInvalidDecl();
15186 return;
15187 }
15188
15189 SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
15190
15191 // The exception specification is needed because we are defining the
15192 // function.
15193 ResolveExceptionSpec(CurrentLocation,
15194 CopyAssignOperator->getType()->castAs<FunctionProtoType>());
15195
15196 // Add a context note for diagnostics produced after this point.
15197 Scope.addContextNote(CurrentLocation);
15198
15199 // C++11 [class.copy]p18:
15200 // The [definition of an implicitly declared copy assignment operator] is
15201 // deprecated if the class has a user-declared copy constructor or a
15202 // user-declared destructor.
15203 if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
15204 diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator);
15205
15206 // C++0x [class.copy]p30:
15207 // The implicitly-defined or explicitly-defaulted copy assignment operator
15208 // for a non-union class X performs memberwise copy assignment of its
15209 // subobjects. The direct base classes of X are assigned first, in the
15210 // order of their declaration in the base-specifier-list, and then the
15211 // immediate non-static data members of X are assigned, in the order in
15212 // which they were declared in the class definition.
15213
15214 // The statements that form the synthesized function body.
15215 SmallVector<Stmt*, 8> Statements;
15216
15217 // The parameter for the "other" object, which we are copying from.
15218 ParmVarDecl *Other = CopyAssignOperator->getNonObjectParameter(0);
15219 Qualifiers OtherQuals = Other->getType().getQualifiers();
15220 QualType OtherRefType = Other->getType();
15221 if (OtherRefType->isLValueReferenceType()) {
15222 OtherRefType = OtherRefType->getPointeeType();
15223 OtherQuals = OtherRefType.getQualifiers();
15224 }
15225
15226 // Our location for everything implicitly-generated.
15227 SourceLocation Loc = CopyAssignOperator->getEndLoc().isValid()
15228 ? CopyAssignOperator->getEndLoc()
15229 : CopyAssignOperator->getLocation();
15230
15231 // Builds a DeclRefExpr for the "other" object.
15232 RefBuilder OtherRef(Other, OtherRefType);
15233
15234 // Builds the function object parameter.
15235 std::optional<ThisBuilder> This;
15236 std::optional<DerefBuilder> DerefThis;
15237 std::optional<RefBuilder> ExplicitObject;
15238 bool IsArrow = false;
15239 QualType ObjectType;
15240 if (CopyAssignOperator->isExplicitObjectMemberFunction()) {
15241 ObjectType = CopyAssignOperator->getParamDecl(0)->getType();
15242 if (ObjectType->isReferenceType())
15243 ObjectType = ObjectType->getPointeeType();
15244 ExplicitObject.emplace(CopyAssignOperator->getParamDecl(0), ObjectType);
15245 } else {
15246 ObjectType = getCurrentThisType();
15247 This.emplace();
15248 DerefThis.emplace(*This);
15249 IsArrow = !LangOpts.HLSL;
15250 }
15251 ExprBuilder &ObjectParameter =
15252 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15253 : static_cast<ExprBuilder &>(*This);
15254
15255 // Assign base classes.
15256 bool Invalid = false;
15257 for (auto &Base : ClassDecl->bases()) {
15258 // Form the assignment:
15259 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
15260 QualType BaseType = Base.getType().getUnqualifiedType();
15261 if (!BaseType->isRecordType()) {
15262 Invalid = true;
15263 continue;
15264 }
15265
15266 CXXCastPath BasePath;
15267 BasePath.push_back(&Base);
15268
15269 // Construct the "from" expression, which is an implicit cast to the
15270 // appropriately-qualified base type.
15271 CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
15272 VK_LValue, BasePath);
15273
15274 // Dereference "this".
15275 CastBuilder To(
15276 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15277 : static_cast<ExprBuilder &>(*DerefThis),
15278 Context.getQualifiedType(BaseType, ObjectType.getQualifiers()),
15279 VK_LValue, BasePath);
15280
15281 // Build the copy.
15282 StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
15283 To, From,
15284 /*CopyingBaseSubobject=*/true,
15285 /*Copying=*/true);
15286 if (Copy.isInvalid()) {
15287 CopyAssignOperator->setInvalidDecl();
15288 return;
15289 }
15290
15291 // Success! Record the copy.
15292 Statements.push_back(Copy.getAs<Expr>());
15293 }
15294
15295 // Assign non-static members.
15296 for (auto *Field : ClassDecl->fields()) {
15297 // FIXME: We should form some kind of AST representation for the implied
15298 // memcpy in a union copy operation.
15299 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15300 continue;
15301
15302 if (Field->isInvalidDecl()) {
15303 Invalid = true;
15304 continue;
15305 }
15306
15307 // Check for members of reference type; we can't copy those.
15308 if (Field->getType()->isReferenceType()) {
15309 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15310 << Context.getCanonicalTagType(ClassDecl) << 0
15311 << Field->getDeclName();
15312 Diag(Field->getLocation(), diag::note_declared_at);
15313 Invalid = true;
15314 continue;
15315 }
15316
15317 // Check for members of const-qualified, non-class type.
15318 QualType BaseType = Context.getBaseElementType(Field->getType());
15319 if (!BaseType->isRecordType() && BaseType.isConstQualified()) {
15320 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15321 << Context.getCanonicalTagType(ClassDecl) << 1
15322 << Field->getDeclName();
15323 Diag(Field->getLocation(), diag::note_declared_at);
15324 Invalid = true;
15325 continue;
15326 }
15327
15328 // Suppress assigning zero-width bitfields.
15329 if (Field->isZeroLengthBitField())
15330 continue;
15331
15332 QualType FieldType = Field->getType().getNonReferenceType();
15333 if (FieldType->isIncompleteArrayType()) {
15334 assert(ClassDecl->hasFlexibleArrayMember() &&
15335 "Incomplete array type is not valid");
15336 continue;
15337 }
15338
15339 // Build references to the field in the object we're copying from and to.
15340 CXXScopeSpec SS; // Intentionally empty
15341 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
15343 MemberLookup.addDecl(Field);
15344 MemberLookup.resolveKind();
15345
15346 MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
15347 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15348 // Build the copy of this field.
15349 StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
15350 To, From,
15351 /*CopyingBaseSubobject=*/false,
15352 /*Copying=*/true);
15353 if (Copy.isInvalid()) {
15354 CopyAssignOperator->setInvalidDecl();
15355 return;
15356 }
15357
15358 // Success! Record the copy.
15359 Statements.push_back(Copy.getAs<Stmt>());
15360 }
15361
15362 if (!Invalid) {
15363 // Add a "return *this;"
15364 Expr *ThisExpr =
15365 (ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15366 : LangOpts.HLSL ? static_cast<ExprBuilder &>(*This)
15367 : static_cast<ExprBuilder &>(*DerefThis))
15368 .build(*this, Loc);
15369 StmtResult Return = BuildReturnStmt(Loc, ThisExpr);
15370 if (Return.isInvalid())
15371 Invalid = true;
15372 else
15373 Statements.push_back(Return.getAs<Stmt>());
15374 }
15375
15376 if (Invalid) {
15377 CopyAssignOperator->setInvalidDecl();
15378 return;
15379 }
15380
15381 StmtResult Body;
15382 {
15383 CompoundScopeRAII CompoundScope(*this);
15384 Body = ActOnCompoundStmt(Loc, Loc, Statements,
15385 /*isStmtExpr=*/false);
15386 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
15387 }
15388 CopyAssignOperator->setBody(Body.getAs<Stmt>());
15389 CopyAssignOperator->markUsed(Context);
15390
15392 L->CompletedImplicitDefinition(CopyAssignOperator);
15393 }
15394}
15395
15397 assert(ClassDecl->needsImplicitMoveAssignment());
15398
15399 DeclaringSpecialMember DSM(*this, ClassDecl,
15401 if (DSM.isAlreadyBeingDeclared())
15402 return nullptr;
15403
15404 // Note: The following rules are largely analoguous to the move
15405 // constructor rules.
15406
15408 /*Qualifier=*/std::nullopt, ClassDecl,
15409 /*OwnsTag=*/false);
15411 if (AS != LangAS::Default)
15412 ArgType = Context.getAddrSpaceQualType(ArgType, AS);
15413 QualType RetType = Context.getLValueReferenceType(ArgType);
15414 ArgType = Context.getRValueReferenceType(ArgType);
15415
15417 *this, ClassDecl, CXXSpecialMemberKind::MoveAssignment, false);
15418
15419 // An implicitly-declared move assignment operator is an inline public
15420 // member of its class.
15422 SourceLocation ClassLoc = ClassDecl->getLocation();
15423 DeclarationNameInfo NameInfo(Name, ClassLoc);
15425 Context, ClassDecl, ClassLoc, NameInfo, QualType(),
15426 /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
15427 getCurFPFeatures().isFPConstrained(),
15428 /*isInline=*/true,
15430 SourceLocation());
15431 MoveAssignment->setAccess(AS_public);
15432 MoveAssignment->setDefaulted();
15433 MoveAssignment->setImplicit();
15434
15435 setupImplicitSpecialMemberType(MoveAssignment, RetType, ArgType);
15436
15437 if (getLangOpts().CUDA)
15440 /* ConstRHS */ false,
15441 /* Diagnose */ false);
15442
15443 // Add the parameter to the operator.
15445 ClassLoc, ClassLoc,
15446 /*Id=*/nullptr, ArgType,
15447 /*TInfo=*/nullptr, SC_None,
15448 nullptr);
15449 MoveAssignment->setParams(FromParam);
15450
15451 MoveAssignment->setTrivial(
15455 : ClassDecl->hasTrivialMoveAssignment());
15456
15457 // Note that we have added this copy-assignment operator.
15459
15460 Scope *S = getScopeForContext(ClassDecl);
15462
15466 SetDeclDeleted(MoveAssignment, ClassLoc);
15467 }
15468
15469 if (S)
15471 ClassDecl->addDecl(MoveAssignment);
15472
15473 return MoveAssignment;
15474}
15475
15476/// Check if we're implicitly defining a move assignment operator for a class
15477/// with virtual bases. Such a move assignment might move-assign the virtual
15478/// base multiple times.
15480 SourceLocation CurrentLocation) {
15481 assert(!Class->isDependentContext() && "should not define dependent move");
15482
15483 // Only a virtual base could get implicitly move-assigned multiple times.
15484 // Only a non-trivial move assignment can observe this. We only want to
15485 // diagnose if we implicitly define an assignment operator that assigns
15486 // two base classes, both of which move-assign the same virtual base.
15487 if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
15488 Class->getNumBases() < 2)
15489 return;
15490
15492 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15493 VBaseMap VBases;
15494
15495 for (auto &BI : Class->bases()) {
15496 Worklist.push_back(&BI);
15497 while (!Worklist.empty()) {
15498 CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
15499 CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
15500
15501 // If the base has no non-trivial move assignment operators,
15502 // we don't care about moves from it.
15503 if (!Base->hasNonTrivialMoveAssignment())
15504 continue;
15505
15506 // If there's nothing virtual here, skip it.
15507 if (!BaseSpec->isVirtual() && !Base->getNumVBases())
15508 continue;
15509
15510 // If we're not actually going to call a move assignment for this base,
15511 // or the selected move assignment is trivial, skip it.
15514 /*ConstArg*/ false, /*VolatileArg*/ false,
15515 /*RValueThis*/ true, /*ConstThis*/ false,
15516 /*VolatileThis*/ false);
15517 if (!SMOR.getMethod() || SMOR.getMethod()->isTrivial() ||
15519 continue;
15520
15521 if (BaseSpec->isVirtual()) {
15522 // We're going to move-assign this virtual base, and its move
15523 // assignment operator is not trivial. If this can happen for
15524 // multiple distinct direct bases of Class, diagnose it. (If it
15525 // only happens in one base, we'll diagnose it when synthesizing
15526 // that base class's move assignment operator.)
15527 CXXBaseSpecifier *&Existing =
15528 VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
15529 .first->second;
15530 if (Existing && Existing != &BI) {
15531 S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
15532 << Class << Base;
15533 S.Diag(Existing->getBeginLoc(), diag::note_vbase_moved_here)
15534 << (Base->getCanonicalDecl() ==
15536 << Base << Existing->getType() << Existing->getSourceRange();
15537 S.Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
15538 << (Base->getCanonicalDecl() ==
15539 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15540 << Base << BI.getType() << BaseSpec->getSourceRange();
15541
15542 // Only diagnose each vbase once.
15543 Existing = nullptr;
15544 }
15545 } else {
15546 // Only walk over bases that have defaulted move assignment operators.
15547 // We assume that any user-provided move assignment operator handles
15548 // the multiple-moves-of-vbase case itself somehow.
15549 if (!SMOR.getMethod()->isDefaulted())
15550 continue;
15551
15552 // We're going to move the base classes of Base. Add them to the list.
15553 llvm::append_range(Worklist, llvm::make_pointer_range(Base->bases()));
15554 }
15555 }
15556 }
15557}
15558
15560 CXXMethodDecl *MoveAssignOperator) {
15561 assert((MoveAssignOperator->isDefaulted() &&
15562 MoveAssignOperator->isOverloadedOperator() &&
15563 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
15564 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
15565 !MoveAssignOperator->isDeleted()) &&
15566 "DefineImplicitMoveAssignment called for wrong function");
15567 if (MoveAssignOperator->willHaveBody() || MoveAssignOperator->isInvalidDecl())
15568 return;
15569
15570 CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
15571 if (ClassDecl->isInvalidDecl()) {
15572 MoveAssignOperator->setInvalidDecl();
15573 return;
15574 }
15575
15576 // C++0x [class.copy]p28:
15577 // The implicitly-defined or move assignment operator for a non-union class
15578 // X performs memberwise move assignment of its subobjects. The direct base
15579 // classes of X are assigned first, in the order of their declaration in the
15580 // base-specifier-list, and then the immediate non-static data members of X
15581 // are assigned, in the order in which they were declared in the class
15582 // definition.
15583
15584 // Issue a warning if our implicit move assignment operator will move
15585 // from a virtual base more than once.
15586 checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
15587
15588 SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
15589
15590 // The exception specification is needed because we are defining the
15591 // function.
15592 ResolveExceptionSpec(CurrentLocation,
15593 MoveAssignOperator->getType()->castAs<FunctionProtoType>());
15594
15595 // Add a context note for diagnostics produced after this point.
15596 Scope.addContextNote(CurrentLocation);
15597
15598 // The statements that form the synthesized function body.
15599 SmallVector<Stmt*, 8> Statements;
15600
15601 // The parameter for the "other" object, which we are move from.
15602 ParmVarDecl *Other = MoveAssignOperator->getNonObjectParameter(0);
15603 QualType OtherRefType =
15604 Other->getType()->castAs<RValueReferenceType>()->getPointeeType();
15605
15606 // Our location for everything implicitly-generated.
15607 SourceLocation Loc = MoveAssignOperator->getEndLoc().isValid()
15608 ? MoveAssignOperator->getEndLoc()
15609 : MoveAssignOperator->getLocation();
15610
15611 // Builds a reference to the "other" object.
15612 RefBuilder OtherRef(Other, OtherRefType);
15613 // Cast to rvalue.
15614 MoveCastBuilder MoveOther(OtherRef);
15615
15616 // Builds the function object parameter.
15617 std::optional<ThisBuilder> This;
15618 std::optional<DerefBuilder> DerefThis;
15619 std::optional<RefBuilder> ExplicitObject;
15620 QualType ObjectType;
15621 bool IsArrow = false;
15622 if (MoveAssignOperator->isExplicitObjectMemberFunction()) {
15623 ObjectType = MoveAssignOperator->getParamDecl(0)->getType();
15624 if (ObjectType->isReferenceType())
15625 ObjectType = ObjectType->getPointeeType();
15626 ExplicitObject.emplace(MoveAssignOperator->getParamDecl(0), ObjectType);
15627 } else {
15628 ObjectType = getCurrentThisType();
15629 This.emplace();
15630 DerefThis.emplace(*This);
15631 IsArrow = !getLangOpts().HLSL;
15632 }
15633 ExprBuilder &ObjectParameter =
15634 ExplicitObject ? *ExplicitObject : static_cast<ExprBuilder &>(*This);
15635
15636 // Assign base classes.
15637 bool Invalid = false;
15638 for (auto &Base : ClassDecl->bases()) {
15639 // C++11 [class.copy]p28:
15640 // It is unspecified whether subobjects representing virtual base classes
15641 // are assigned more than once by the implicitly-defined copy assignment
15642 // operator.
15643 // FIXME: Do not assign to a vbase that will be assigned by some other base
15644 // class. For a move-assignment, this can result in the vbase being moved
15645 // multiple times.
15646
15647 // Form the assignment:
15648 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
15649 QualType BaseType = Base.getType().getUnqualifiedType();
15650 if (!BaseType->isRecordType()) {
15651 Invalid = true;
15652 continue;
15653 }
15654
15655 CXXCastPath BasePath;
15656 BasePath.push_back(&Base);
15657
15658 // Construct the "from" expression, which is an implicit cast to the
15659 // appropriately-qualified base type.
15660 CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
15661
15662 // Implicitly cast "this" to the appropriately-qualified base type.
15663 // Dereference "this".
15664 CastBuilder To(
15665 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15666 : static_cast<ExprBuilder &>(*DerefThis),
15667 Context.getQualifiedType(BaseType, ObjectType.getQualifiers()),
15668 VK_LValue, BasePath);
15669
15670 // Build the move.
15671 StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
15672 To, From,
15673 /*CopyingBaseSubobject=*/true,
15674 /*Copying=*/false);
15675 if (Move.isInvalid()) {
15676 MoveAssignOperator->setInvalidDecl();
15677 return;
15678 }
15679
15680 // Success! Record the move.
15681 Statements.push_back(Move.getAs<Expr>());
15682 }
15683
15684 // Assign non-static members.
15685 for (auto *Field : ClassDecl->fields()) {
15686 // FIXME: We should form some kind of AST representation for the implied
15687 // memcpy in a union copy operation.
15688 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15689 continue;
15690
15691 if (Field->isInvalidDecl()) {
15692 Invalid = true;
15693 continue;
15694 }
15695
15696 // Check for members of reference type; we can't move those.
15697 if (Field->getType()->isReferenceType()) {
15698 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15699 << Context.getCanonicalTagType(ClassDecl) << 0
15700 << Field->getDeclName();
15701 Diag(Field->getLocation(), diag::note_declared_at);
15702 Invalid = true;
15703 continue;
15704 }
15705
15706 // Check for members of const-qualified, non-class type.
15707 QualType BaseType = Context.getBaseElementType(Field->getType());
15708 if (!BaseType->isRecordType() && BaseType.isConstQualified()) {
15709 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15710 << Context.getCanonicalTagType(ClassDecl) << 1
15711 << Field->getDeclName();
15712 Diag(Field->getLocation(), diag::note_declared_at);
15713 Invalid = true;
15714 continue;
15715 }
15716
15717 // Suppress assigning zero-width bitfields.
15718 if (Field->isZeroLengthBitField())
15719 continue;
15720
15721 QualType FieldType = Field->getType().getNonReferenceType();
15722 if (FieldType->isIncompleteArrayType()) {
15723 assert(ClassDecl->hasFlexibleArrayMember() &&
15724 "Incomplete array type is not valid");
15725 continue;
15726 }
15727
15728 // Build references to the field in the object we're copying from and to.
15729 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
15731 MemberLookup.addDecl(Field);
15732 MemberLookup.resolveKind();
15733 MemberBuilder From(MoveOther, OtherRefType,
15734 /*IsArrow=*/false, MemberLookup);
15735 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15736
15737 assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
15738 "Member reference with rvalue base must be rvalue except for reference "
15739 "members, which aren't allowed for move assignment.");
15740
15741 // Build the move of this field.
15742 StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
15743 To, From,
15744 /*CopyingBaseSubobject=*/false,
15745 /*Copying=*/false);
15746 if (Move.isInvalid()) {
15747 MoveAssignOperator->setInvalidDecl();
15748 return;
15749 }
15750
15751 // Success! Record the copy.
15752 Statements.push_back(Move.getAs<Stmt>());
15753 }
15754
15755 if (!Invalid) {
15756 // Add a "return *this;"
15757 Expr *ThisExpr =
15758 (ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15759 : LangOpts.HLSL ? static_cast<ExprBuilder &>(*This)
15760 : static_cast<ExprBuilder &>(*DerefThis))
15761 .build(*this, Loc);
15762
15763 StmtResult Return = BuildReturnStmt(Loc, ThisExpr);
15764 if (Return.isInvalid())
15765 Invalid = true;
15766 else
15767 Statements.push_back(Return.getAs<Stmt>());
15768 }
15769
15770 if (Invalid) {
15771 MoveAssignOperator->setInvalidDecl();
15772 return;
15773 }
15774
15775 StmtResult Body;
15776 {
15777 CompoundScopeRAII CompoundScope(*this);
15778 Body = ActOnCompoundStmt(Loc, Loc, Statements,
15779 /*isStmtExpr=*/false);
15780 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
15781 }
15782 MoveAssignOperator->setBody(Body.getAs<Stmt>());
15783 MoveAssignOperator->markUsed(Context);
15784
15786 L->CompletedImplicitDefinition(MoveAssignOperator);
15787 }
15788}
15789
15791 CXXRecordDecl *ClassDecl) {
15792 // C++ [class.copy]p4:
15793 // If the class definition does not explicitly declare a copy
15794 // constructor, one is declared implicitly.
15795 assert(ClassDecl->needsImplicitCopyConstructor());
15796
15797 DeclaringSpecialMember DSM(*this, ClassDecl,
15799 if (DSM.isAlreadyBeingDeclared())
15800 return nullptr;
15801
15803 /*Qualifier=*/std::nullopt, ClassDecl,
15804 /*OwnsTag=*/false);
15805 QualType ArgType = ClassType;
15806 bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
15807 if (Const)
15808 ArgType = ArgType.withConst();
15809
15811 if (AS != LangAS::Default)
15812 ArgType = Context.getAddrSpaceQualType(ArgType, AS);
15813
15814 ArgType = Context.getLValueReferenceType(ArgType);
15815
15817 *this, ClassDecl, CXXSpecialMemberKind::CopyConstructor, Const);
15818
15819 DeclarationName Name
15821 Context.getCanonicalType(ClassType));
15822 SourceLocation ClassLoc = ClassDecl->getLocation();
15823 DeclarationNameInfo NameInfo(Name, ClassLoc);
15824
15825 // An implicitly-declared copy constructor is an inline public
15826 // member of its class.
15828 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
15829 ExplicitSpecifier(), getCurFPFeatures().isFPConstrained(),
15830 /*isInline=*/true,
15831 /*isImplicitlyDeclared=*/true,
15834 CopyConstructor->setAccess(AS_public);
15835 CopyConstructor->setDefaulted();
15836
15837 setupImplicitSpecialMemberType(CopyConstructor, Context.VoidTy, ArgType);
15838
15839 if (getLangOpts().CUDA)
15842 /* ConstRHS */ Const,
15843 /* Diagnose */ false);
15844
15845 // During template instantiation of special member functions we need a
15846 // reliable TypeSourceInfo for the parameter types in order to allow functions
15847 // to be substituted.
15848 TypeSourceInfo *TSI = nullptr;
15849 if (inTemplateInstantiation() && ClassDecl->isLambda())
15850 TSI = Context.getTrivialTypeSourceInfo(ArgType);
15851
15852 // Add the parameter to the constructor.
15853 ParmVarDecl *FromParam =
15854 ParmVarDecl::Create(Context, CopyConstructor, ClassLoc, ClassLoc,
15855 /*IdentifierInfo=*/nullptr, ArgType,
15856 /*TInfo=*/TSI, SC_None, nullptr);
15857 CopyConstructor->setParams(FromParam);
15858
15859 CopyConstructor->setTrivial(
15863 : ClassDecl->hasTrivialCopyConstructor());
15864
15865 CopyConstructor->setTrivialForCall(
15866 ClassDecl->hasAttr<TrivialABIAttr>() ||
15871 : ClassDecl->hasTrivialCopyConstructorForCall()));
15872
15873 // Note that we have declared this constructor.
15875
15876 Scope *S = getScopeForContext(ClassDecl);
15878
15883 }
15884
15885 if (S)
15887 ClassDecl->addDecl(CopyConstructor);
15888
15889 return CopyConstructor;
15890}
15891
15894 assert((CopyConstructor->isDefaulted() &&
15895 CopyConstructor->isCopyConstructor() &&
15896 !CopyConstructor->doesThisDeclarationHaveABody() &&
15897 !CopyConstructor->isDeleted()) &&
15898 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
15899 if (CopyConstructor->willHaveBody() || CopyConstructor->isInvalidDecl())
15900 return;
15901
15902 CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
15903 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
15904
15906
15907 // The exception specification is needed because we are defining the
15908 // function.
15909 ResolveExceptionSpec(CurrentLocation,
15910 CopyConstructor->getType()->castAs<FunctionProtoType>());
15911 MarkVTableUsed(CurrentLocation, ClassDecl);
15912
15913 // Add a context note for diagnostics produced after this point.
15914 Scope.addContextNote(CurrentLocation);
15915
15916 // C++11 [class.copy]p7:
15917 // The [definition of an implicitly declared copy constructor] is
15918 // deprecated if the class has a user-declared copy assignment operator
15919 // or a user-declared destructor.
15920 if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
15922
15923 if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false)) {
15924 CopyConstructor->setInvalidDecl();
15925 } else {
15926 SourceLocation Loc = CopyConstructor->getEndLoc().isValid()
15927 ? CopyConstructor->getEndLoc()
15928 : CopyConstructor->getLocation();
15929 Sema::CompoundScopeRAII CompoundScope(*this);
15930 CopyConstructor->setBody(
15931 ActOnCompoundStmt(Loc, Loc, {}, /*isStmtExpr=*/false).getAs<Stmt>());
15932 CopyConstructor->markUsed(Context);
15933 }
15934
15936 L->CompletedImplicitDefinition(CopyConstructor);
15937 }
15938}
15939
15941 CXXRecordDecl *ClassDecl) {
15942 assert(ClassDecl->needsImplicitMoveConstructor());
15943
15944 DeclaringSpecialMember DSM(*this, ClassDecl,
15946 if (DSM.isAlreadyBeingDeclared())
15947 return nullptr;
15948
15950 /*Qualifier=*/std::nullopt, ClassDecl,
15951 /*OwnsTag=*/false);
15952
15953 QualType ArgType = ClassType;
15955 if (AS != LangAS::Default)
15956 ArgType = Context.getAddrSpaceQualType(ClassType, AS);
15957 ArgType = Context.getRValueReferenceType(ArgType);
15958
15960 *this, ClassDecl, CXXSpecialMemberKind::MoveConstructor, false);
15961
15962 DeclarationName Name
15964 Context.getCanonicalType(ClassType));
15965 SourceLocation ClassLoc = ClassDecl->getLocation();
15966 DeclarationNameInfo NameInfo(Name, ClassLoc);
15967
15968 // C++11 [class.copy]p11:
15969 // An implicitly-declared copy/move constructor is an inline public
15970 // member of its class.
15972 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
15973 ExplicitSpecifier(), getCurFPFeatures().isFPConstrained(),
15974 /*isInline=*/true,
15975 /*isImplicitlyDeclared=*/true,
15978 MoveConstructor->setAccess(AS_public);
15979 MoveConstructor->setDefaulted();
15980
15981 setupImplicitSpecialMemberType(MoveConstructor, Context.VoidTy, ArgType);
15982
15983 if (getLangOpts().CUDA)
15986 /* ConstRHS */ false,
15987 /* Diagnose */ false);
15988
15989 // Add the parameter to the constructor.
15991 ClassLoc, ClassLoc,
15992 /*IdentifierInfo=*/nullptr,
15993 ArgType, /*TInfo=*/nullptr,
15994 SC_None, nullptr);
15995 MoveConstructor->setParams(FromParam);
15996
15997 MoveConstructor->setTrivial(
16001 : ClassDecl->hasTrivialMoveConstructor());
16002
16003 MoveConstructor->setTrivialForCall(
16004 ClassDecl->hasAttr<TrivialABIAttr>() ||
16009 : ClassDecl->hasTrivialMoveConstructorForCall()));
16010
16011 // Note that we have declared this constructor.
16013
16014 Scope *S = getScopeForContext(ClassDecl);
16016
16021 }
16022
16023 if (S)
16025 ClassDecl->addDecl(MoveConstructor);
16026
16027 return MoveConstructor;
16028}
16029
16032 assert((MoveConstructor->isDefaulted() &&
16033 MoveConstructor->isMoveConstructor() &&
16034 !MoveConstructor->doesThisDeclarationHaveABody() &&
16035 !MoveConstructor->isDeleted()) &&
16036 "DefineImplicitMoveConstructor - call it for implicit move ctor");
16037 if (MoveConstructor->willHaveBody() || MoveConstructor->isInvalidDecl())
16038 return;
16039
16040 CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
16041 assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
16042
16044
16045 // The exception specification is needed because we are defining the
16046 // function.
16047 ResolveExceptionSpec(CurrentLocation,
16048 MoveConstructor->getType()->castAs<FunctionProtoType>());
16049 MarkVTableUsed(CurrentLocation, ClassDecl);
16050
16051 // Add a context note for diagnostics produced after this point.
16052 Scope.addContextNote(CurrentLocation);
16053
16054 if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false)) {
16055 MoveConstructor->setInvalidDecl();
16056 } else {
16057 SourceLocation Loc = MoveConstructor->getEndLoc().isValid()
16058 ? MoveConstructor->getEndLoc()
16059 : MoveConstructor->getLocation();
16060 Sema::CompoundScopeRAII CompoundScope(*this);
16061 MoveConstructor->setBody(
16062 ActOnCompoundStmt(Loc, Loc, {}, /*isStmtExpr=*/false).getAs<Stmt>());
16063 MoveConstructor->markUsed(Context);
16064 }
16065
16067 L->CompletedImplicitDefinition(MoveConstructor);
16068 }
16069}
16070
16072 return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
16073}
16074
16076 SourceLocation CurrentLocation,
16077 CXXConversionDecl *Conv) {
16078 SynthesizedFunctionScope Scope(*this, Conv);
16079 assert(!Conv->getReturnType()->isUndeducedType());
16080
16081 QualType ConvRT = Conv->getType()->castAs<FunctionType>()->getReturnType();
16082 CallingConv CC =
16083 ConvRT->getPointeeType()->castAs<FunctionType>()->getCallConv();
16084
16085 CXXRecordDecl *Lambda = Conv->getParent();
16086 FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
16087 FunctionDecl *Invoker =
16088 CallOp->hasCXXExplicitFunctionObjectParameter() || CallOp->isStatic()
16089 ? CallOp
16090 : Lambda->getLambdaStaticInvoker(CC);
16091
16092 if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
16094 CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
16095 if (!CallOp)
16096 return;
16097
16098 if (CallOp != Invoker) {
16100 Invoker->getDescribedFunctionTemplate(), TemplateArgs,
16101 CurrentLocation);
16102 if (!Invoker)
16103 return;
16104 }
16105 }
16106
16107 if (CallOp->isInvalidDecl())
16108 return;
16109
16110 // Mark the call operator referenced (and add to pending instantiations
16111 // if necessary).
16112 // For both the conversion and static-invoker template specializations
16113 // we construct their body's in this function, so no need to add them
16114 // to the PendingInstantiations.
16115 MarkFunctionReferenced(CurrentLocation, CallOp);
16116
16117 if (Invoker != CallOp) {
16118 // Fill in the __invoke function with a dummy implementation. IR generation
16119 // will fill in the actual details. Update its type in case it contained
16120 // an 'auto'.
16121 Invoker->markUsed(Context);
16122 Invoker->setReferenced();
16123 Invoker->setType(Conv->getReturnType()->getPointeeType());
16124 Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
16125 }
16126
16127 // Construct the body of the conversion function { return __invoke; }.
16128 Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(), VK_LValue,
16129 Conv->getLocation());
16130 assert(FunctionRef && "Can't refer to __invoke function?");
16131 Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
16133 Conv->getLocation(), Conv->getLocation()));
16134 Conv->markUsed(Context);
16135 Conv->setReferenced();
16136
16138 L->CompletedImplicitDefinition(Conv);
16139 if (Invoker != CallOp)
16140 L->CompletedImplicitDefinition(Invoker);
16141 }
16142}
16143
16145 SourceLocation CurrentLocation, CXXConversionDecl *Conv) {
16146 assert(!Conv->getParent()->isGenericLambda());
16147
16148 SynthesizedFunctionScope Scope(*this, Conv);
16149
16150 // Copy-initialize the lambda object as needed to capture it.
16151 Expr *This = ActOnCXXThis(CurrentLocation).get();
16152 Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
16153
16154 ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
16155 Conv->getLocation(),
16156 Conv, DerefThis);
16157
16158 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
16159 // behavior. Note that only the general conversion function does this
16160 // (since it's unusable otherwise); in the case where we inline the
16161 // block literal, it has block literal lifetime semantics.
16162 if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
16163 BuildBlock = ImplicitCastExpr::Create(
16164 Context, BuildBlock.get()->getType(), CK_CopyAndAutoreleaseBlockObject,
16165 BuildBlock.get(), nullptr, VK_PRValue, FPOptionsOverride());
16166
16167 if (BuildBlock.isInvalid()) {
16168 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16169 Conv->setInvalidDecl();
16170 return;
16171 }
16172
16173 // Create the return statement that returns the block from the conversion
16174 // function.
16175 StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
16176 if (Return.isInvalid()) {
16177 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16178 Conv->setInvalidDecl();
16179 return;
16180 }
16181
16182 // Set the body of the conversion function.
16183 Stmt *ReturnS = Return.get();
16185 Conv->getLocation(), Conv->getLocation()));
16186 Conv->markUsed(Context);
16187
16188 // We're done; notify the mutation listener, if any.
16190 L->CompletedImplicitDefinition(Conv);
16191 }
16192}
16193
16194/// Determine whether the given list arguments contains exactly one
16195/// "real" (non-default) argument.
16197 switch (Args.size()) {
16198 case 0:
16199 return false;
16200
16201 default:
16202 if (!Args[1]->isDefaultArgument())
16203 return false;
16204
16205 [[fallthrough]];
16206 case 1:
16207 return !Args[0]->isDefaultArgument();
16208 }
16209
16210 return false;
16211}
16212
16214 SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl,
16216 bool HadMultipleCandidates, bool IsListInitialization,
16217 bool IsStdInitListInitialization, bool RequiresZeroInit,
16218 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
16219 bool Elidable = false;
16220
16221 // C++0x [class.copy]p34:
16222 // When certain criteria are met, an implementation is allowed to
16223 // omit the copy/move construction of a class object, even if the
16224 // copy/move constructor and/or destructor for the object have
16225 // side effects. [...]
16226 // - when a temporary class object that has not been bound to a
16227 // reference (12.2) would be copied/moved to a class object
16228 // with the same cv-unqualified type, the copy/move operation
16229 // can be omitted by constructing the temporary object
16230 // directly into the target of the omitted copy/move
16231 if (ConstructKind == CXXConstructionKind::Complete && Constructor &&
16232 // FIXME: Converting constructors should also be accepted.
16233 // But to fix this, the logic that digs down into a CXXConstructExpr
16234 // to find the source object needs to handle it.
16235 // Right now it assumes the source object is passed directly as the
16236 // first argument.
16237 Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
16238 Expr *SubExpr = ExprArgs[0];
16239 // FIXME: Per above, this is also incorrect if we want to accept
16240 // converting constructors, as isTemporaryObject will
16241 // reject temporaries with different type from the
16242 // CXXRecord itself.
16243 Elidable = SubExpr->isTemporaryObject(
16244 Context, cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
16245 }
16246
16247 return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
16248 FoundDecl, Constructor,
16249 Elidable, ExprArgs, HadMultipleCandidates,
16250 IsListInitialization,
16251 IsStdInitListInitialization, RequiresZeroInit,
16252 ConstructKind, ParenRange);
16253}
16254
16256 SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl,
16257 CXXConstructorDecl *Constructor, bool Elidable, MultiExprArg ExprArgs,
16258 bool HadMultipleCandidates, bool IsListInitialization,
16259 bool IsStdInitListInitialization, bool RequiresZeroInit,
16260 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
16261 if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
16262 Constructor = findInheritingConstructor(ConstructLoc, Constructor, Shadow);
16263 // The only way to get here is if we did overload resolution to find the
16264 // shadow decl, so we don't need to worry about re-checking the trailing
16265 // requires clause.
16266 if (DiagnoseUseOfOverloadedDecl(Constructor, ConstructLoc))
16267 return ExprError();
16268 }
16269
16270 return BuildCXXConstructExpr(
16271 ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
16272 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
16273 RequiresZeroInit, ConstructKind, ParenRange);
16274}
16275
16276/// BuildCXXConstructExpr - Creates a complete call to a constructor,
16277/// including handling of its default argument expressions.
16279 SourceLocation ConstructLoc, QualType DeclInitType,
16280 CXXConstructorDecl *Constructor, bool Elidable, MultiExprArg ExprArgs,
16281 bool HadMultipleCandidates, bool IsListInitialization,
16282 bool IsStdInitListInitialization, bool RequiresZeroInit,
16283 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
16284 assert(declaresSameEntity(
16285 Constructor->getParent(),
16286 DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
16287 "given constructor for wrong type");
16288 MarkFunctionReferenced(ConstructLoc, Constructor);
16289 if (getLangOpts().CUDA && !CUDA().CheckCall(ConstructLoc, Constructor))
16290 return ExprError();
16291
16294 Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
16295 HadMultipleCandidates, IsListInitialization,
16296 IsStdInitListInitialization, RequiresZeroInit,
16297 static_cast<CXXConstructionKind>(ConstructKind), ParenRange),
16298 Constructor);
16299}
16300
16302 if (VD->isInvalidDecl()) return;
16303 // If initializing the variable failed, don't also diagnose problems with
16304 // the destructor, they're likely related.
16305 if (VD->getInit() && VD->getInit()->containsErrors())
16306 return;
16307
16308 ClassDecl = ClassDecl->getDefinitionOrSelf();
16309 if (ClassDecl->isInvalidDecl()) return;
16310 if (ClassDecl->hasIrrelevantDestructor()) return;
16311 if (ClassDecl->isDependentContext()) return;
16312
16313 if (VD->isNoDestroy(getASTContext()))
16314 return;
16315
16317 // The result of `LookupDestructor` might be nullptr if the destructor is
16318 // invalid, in which case it is marked as `IneligibleOrNotSelected` and
16319 // will not be selected by `CXXRecordDecl::getDestructor()`.
16320 if (!Destructor)
16321 return;
16322 // If this is an array, we'll require the destructor during initialization, so
16323 // we can skip over this. We still want to emit exit-time destructor warnings
16324 // though.
16325 if (!VD->getType()->isArrayType()) {
16328 PDiag(diag::err_access_dtor_var)
16329 << VD->getDeclName() << VD->getType());
16331 }
16332
16333 if (Destructor->isTrivial()) return;
16334
16335 // If the destructor is constexpr, check whether the variable has constant
16336 // destruction now.
16337 if (Destructor->isConstexpr()) {
16338 bool HasConstantInit = false;
16339 if (VD->getInit() && !VD->getInit()->isValueDependent())
16340 HasConstantInit = VD->evaluateValue();
16342 if (!VD->evaluateDestruction(Notes) && VD->isConstexpr() &&
16343 HasConstantInit) {
16344 Diag(VD->getLocation(),
16345 diag::err_constexpr_var_requires_const_destruction) << VD;
16346 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
16347 Diag(Notes[I].first, Notes[I].second);
16348 }
16349 }
16350
16351 if (!VD->hasGlobalStorage() || !VD->needsDestruction(Context))
16352 return;
16353
16354 // Emit warning for non-trivial dtor in global scope (a real global,
16355 // class-static, function-static).
16356 if (!VD->hasAttr<AlwaysDestroyAttr>())
16357 Diag(VD->getLocation(), diag::warn_exit_time_destructor);
16358
16359 // TODO: this should be re-enabled for static locals by !CXAAtExit
16360 if (!VD->isStaticLocal())
16361 Diag(VD->getLocation(), diag::warn_global_destructor);
16362}
16363
16365 QualType DeclInitType, MultiExprArg ArgsPtr,
16367 SmallVectorImpl<Expr *> &ConvertedArgs,
16368 bool AllowExplicit,
16369 bool IsListInitialization) {
16370 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
16371 unsigned NumArgs = ArgsPtr.size();
16372 Expr **Args = ArgsPtr.data();
16373
16374 const auto *Proto = Constructor->getType()->castAs<FunctionProtoType>();
16375 unsigned NumParams = Proto->getNumParams();
16376
16377 // If too few arguments are available, we'll fill in the rest with defaults.
16378 if (NumArgs < NumParams)
16379 ConvertedArgs.reserve(NumParams);
16380 else
16381 ConvertedArgs.reserve(NumArgs);
16382
16383 VariadicCallType CallType = Proto->isVariadic()
16386 SmallVector<Expr *, 8> AllArgs;
16388 Loc, Constructor, Proto, 0, llvm::ArrayRef(Args, NumArgs), AllArgs,
16389 CallType, AllowExplicit, IsListInitialization);
16390 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
16391
16393
16394 CheckConstructorCall(Constructor, DeclInitType, llvm::ArrayRef(AllArgs),
16395 Proto, Loc);
16396
16397 return Invalid;
16398}
16399
16401 bool SeenTypedOperators = Context.hasSeenTypeAwareOperatorNewOrDelete();
16402 return typeAwareAllocationModeFromBool(SeenTypedOperators);
16403}
16404
16407 QualType DeallocType, SourceLocation Loc) {
16408 if (DeallocType.isNull())
16409 return nullptr;
16410
16411 FunctionDecl *FnDecl = FnTemplateDecl->getTemplatedDecl();
16412 if (!FnDecl->isTypeAwareOperatorNewOrDelete())
16413 return nullptr;
16414
16415 if (FnDecl->isVariadic())
16416 return nullptr;
16417
16418 unsigned NumParams = FnDecl->getNumParams();
16419 constexpr unsigned RequiredParameterCount =
16421 // A usual deallocation function has no placement parameters
16422 if (NumParams != RequiredParameterCount)
16423 return nullptr;
16424
16425 // A type aware allocation is only usual if the only dependent parameter is
16426 // the first parameter.
16427 if (llvm::any_of(FnDecl->parameters().drop_front(),
16428 [](const ParmVarDecl *ParamDecl) {
16429 return ParamDecl->getType()->isDependentType();
16430 }))
16431 return nullptr;
16432
16433 QualType SpecializedTypeIdentity = tryBuildStdTypeIdentity(DeallocType, Loc);
16434 if (SpecializedTypeIdentity.isNull())
16435 return nullptr;
16436
16438 ArgTypes.reserve(NumParams);
16439
16440 // The first parameter to a type aware operator delete is by definition the
16441 // type-identity argument, so we explicitly set this to the target
16442 // type-identity type, the remaining usual parameters should then simply match
16443 // the type declared in the function template.
16444 ArgTypes.push_back(SpecializedTypeIdentity);
16445 for (unsigned ParamIdx = 1; ParamIdx < RequiredParameterCount; ++ParamIdx)
16446 ArgTypes.push_back(FnDecl->getParamDecl(ParamIdx)->getType());
16447
16449 QualType ExpectedFunctionType =
16450 Context.getFunctionType(Context.VoidTy, ArgTypes, EPI);
16453 if (DeduceTemplateArguments(FnTemplateDecl, nullptr, ExpectedFunctionType,
16455 return nullptr;
16456 return Result;
16457}
16458
16459static inline bool
16461 const FunctionDecl *FnDecl) {
16462 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
16463 if (isa<NamespaceDecl>(DC)) {
16464 return SemaRef.Diag(FnDecl->getLocation(),
16465 diag::err_operator_new_delete_declared_in_namespace)
16466 << FnDecl->getDeclName();
16467 }
16468
16469 if (isa<TranslationUnitDecl>(DC) &&
16470 FnDecl->getStorageClass() == SC_Static) {
16471 return SemaRef.Diag(FnDecl->getLocation(),
16472 diag::err_operator_new_delete_declared_static)
16473 << FnDecl->getDeclName();
16474 }
16475
16476 return false;
16477}
16478
16480 const PointerType *PtrTy) {
16481 auto &Ctx = SemaRef.Context;
16482 Qualifiers PtrQuals = PtrTy->getPointeeType().getQualifiers();
16483 PtrQuals.removeAddressSpace();
16485 PtrTy->getPointeeType().getUnqualifiedType(), PtrQuals)));
16486}
16487
16489
16491 const FunctionDecl *FD,
16492 bool *WasMalformed) {
16493 const Decl *MalformedDecl = nullptr;
16494 if (FD->getNumParams() > 0 &&
16496 /*TypeArgument=*/nullptr, &MalformedDecl))
16497 return true;
16498
16499 if (!MalformedDecl)
16500 return false;
16501
16502 if (WasMalformed)
16503 *WasMalformed = true;
16504
16505 return true;
16506}
16507
16509 auto *RD = Type->getAsCXXRecordDecl();
16510 return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
16511 RD->getIdentifier()->isStr("destroying_delete_t");
16512}
16513
16515 const FunctionDecl *FD) {
16516 // C++ P0722:
16517 // Within a class C, a single object deallocation function with signature
16518 // (T, std::destroying_delete_t, <more params>)
16519 // is a destroying operator delete.
16520 bool IsPotentiallyTypeAware = IsPotentiallyTypeAwareOperatorNewOrDelete(
16521 SemaRef, FD, /*WasMalformed=*/nullptr);
16522 unsigned DestroyingDeleteIdx = IsPotentiallyTypeAware + /* address */ 1;
16523 return isa<CXXMethodDecl>(FD) && FD->getOverloadedOperator() == OO_Delete &&
16524 FD->getNumParams() > DestroyingDeleteIdx &&
16525 isDestroyingDeleteT(FD->getParamDecl(DestroyingDeleteIdx)->getType());
16526}
16527
16529 Sema &SemaRef, FunctionDecl *FnDecl, AllocationOperatorKind OperatorKind,
16530 CanQualType ExpectedResultType, CanQualType ExpectedSizeOrAddressParamType,
16531 unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag) {
16532 auto NormalizeType = [&SemaRef](QualType T) {
16533 if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
16534 // The operator is valid on any address space for OpenCL.
16535 // Drop address space from actual and expected result types.
16536 if (const auto PtrTy = T->template getAs<PointerType>())
16538 }
16540 };
16541
16542 const unsigned NumParams = FnDecl->getNumParams();
16543 unsigned FirstNonTypeParam = 0;
16544 bool MalformedTypeIdentity = false;
16545 bool IsPotentiallyTypeAware = IsPotentiallyTypeAwareOperatorNewOrDelete(
16546 SemaRef, FnDecl, &MalformedTypeIdentity);
16547 unsigned MinimumMandatoryArgumentCount = 1;
16548 unsigned SizeParameterIndex = 0;
16549 if (IsPotentiallyTypeAware) {
16550 // We don't emit this diagnosis for template instantiations as we will
16551 // have already emitted it for the original template declaration.
16552 if (!FnDecl->isTemplateInstantiation())
16553 SemaRef.Diag(FnDecl->getLocation(), diag::warn_ext_type_aware_allocators);
16554
16555 if (OperatorKind == AllocationOperatorKind::New) {
16556 SizeParameterIndex = 1;
16557 MinimumMandatoryArgumentCount =
16559 } else {
16560 SizeParameterIndex = 2;
16561 MinimumMandatoryArgumentCount =
16563 }
16564 FirstNonTypeParam = 1;
16565 }
16566
16567 bool IsPotentiallyDestroyingDelete =
16569
16570 if (IsPotentiallyDestroyingDelete) {
16571 ++MinimumMandatoryArgumentCount;
16572 ++SizeParameterIndex;
16573 }
16574
16575 if (NumParams < MinimumMandatoryArgumentCount)
16576 return SemaRef.Diag(FnDecl->getLocation(),
16577 diag::err_operator_new_delete_too_few_parameters)
16578 << IsPotentiallyTypeAware << IsPotentiallyDestroyingDelete
16579 << FnDecl->getDeclName() << MinimumMandatoryArgumentCount;
16580
16581 for (unsigned Idx = 0; Idx < MinimumMandatoryArgumentCount; ++Idx) {
16582 const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(Idx);
16583 if (ParamDecl->hasDefaultArg())
16584 return SemaRef.Diag(FnDecl->getLocation(),
16585 diag::err_operator_new_default_arg)
16586 << FnDecl->getDeclName() << Idx << ParamDecl->getDefaultArgRange();
16587 }
16588
16589 auto *FnType = FnDecl->getType()->castAs<FunctionType>();
16590 QualType CanResultType = NormalizeType(FnType->getReturnType());
16591 QualType CanExpectedResultType = NormalizeType(ExpectedResultType);
16592 QualType CanExpectedSizeOrAddressParamType =
16593 NormalizeType(ExpectedSizeOrAddressParamType);
16594
16595 // Check that the result type is what we expect.
16596 if (CanResultType != CanExpectedResultType) {
16597 // Reject even if the type is dependent; an operator delete function is
16598 // required to have a non-dependent result type.
16599 return SemaRef.Diag(
16600 FnDecl->getLocation(),
16601 CanResultType->isDependentType()
16602 ? diag::err_operator_new_delete_dependent_result_type
16603 : diag::err_operator_new_delete_invalid_result_type)
16604 << FnDecl->getDeclName() << ExpectedResultType;
16605 }
16606
16607 // A function template must have at least 2 parameters.
16608 if (FnDecl->getDescribedFunctionTemplate() && NumParams < 2)
16609 return SemaRef.Diag(FnDecl->getLocation(),
16610 diag::err_operator_new_delete_template_too_few_parameters)
16611 << FnDecl->getDeclName();
16612
16613 auto CheckType = [&](unsigned ParamIdx, QualType ExpectedType,
16614 auto FallbackType) -> bool {
16615 const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(ParamIdx);
16616 if (ExpectedType.isNull()) {
16617 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
16618 << IsPotentiallyTypeAware << IsPotentiallyDestroyingDelete
16619 << FnDecl->getDeclName() << (1 + ParamIdx) << FallbackType
16620 << ParamDecl->getSourceRange();
16621 }
16622 CanQualType CanExpectedTy =
16624 auto ActualParamType =
16625 NormalizeType(ParamDecl->getType().getUnqualifiedType());
16626 if (ActualParamType == CanExpectedTy)
16627 return false;
16628 unsigned Diagnostic = ActualParamType->isDependentType()
16629 ? DependentParamTypeDiag
16630 : InvalidParamTypeDiag;
16631 return SemaRef.Diag(FnDecl->getLocation(), Diagnostic)
16632 << IsPotentiallyTypeAware << IsPotentiallyDestroyingDelete
16633 << FnDecl->getDeclName() << (1 + ParamIdx) << ExpectedType
16634 << FallbackType << ParamDecl->getSourceRange();
16635 };
16636
16637 // Check that the first parameter type is what we expect.
16638 if (CheckType(FirstNonTypeParam, CanExpectedSizeOrAddressParamType, "size_t"))
16639 return true;
16640
16641 FnDecl->setIsDestroyingOperatorDelete(IsPotentiallyDestroyingDelete);
16642
16643 // If the first parameter type is not a type-identity we're done, otherwise
16644 // we need to ensure the size and alignment parameters have the correct type
16645 if (!IsPotentiallyTypeAware)
16646 return false;
16647
16648 if (CheckType(SizeParameterIndex, SemaRef.Context.getSizeType(), "size_t"))
16649 return true;
16650 TagDecl *StdAlignValTDecl = SemaRef.getStdAlignValT();
16652 StdAlignValTDecl ? SemaRef.Context.getCanonicalTagType(StdAlignValTDecl)
16653 : CanQualType();
16654 if (CheckType(SizeParameterIndex + 1, StdAlignValT, "std::align_val_t"))
16655 return true;
16656
16658 return MalformedTypeIdentity;
16659}
16660
16662 // C++ [basic.stc.dynamic.allocation]p1:
16663 // A program is ill-formed if an allocation function is declared in a
16664 // namespace scope other than global scope or declared static in global
16665 // scope.
16667 return true;
16668
16669 CanQualType SizeTy =
16671
16672 // C++ [basic.stc.dynamic.allocation]p1:
16673 // The return type shall be void*. The first parameter shall have type
16674 // std::size_t.
16676 SemaRef, FnDecl, AllocationOperatorKind::New, SemaRef.Context.VoidPtrTy,
16677 SizeTy, diag::err_operator_new_dependent_param_type,
16678 diag::err_operator_new_param_type);
16679}
16680
16681static bool
16683 // C++ [basic.stc.dynamic.deallocation]p1:
16684 // A program is ill-formed if deallocation functions are declared in a
16685 // namespace scope other than global scope or declared static in global
16686 // scope.
16688 return true;
16689
16690 auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
16691 auto ConstructDestroyingDeleteAddressType = [&]() {
16692 assert(MD);
16695 };
16696
16697 // C++ P2719: A destroying operator delete cannot be type aware
16698 // so for QoL we actually check for this explicitly by considering
16699 // an destroying-delete appropriate address type and the presence of
16700 // any parameter of type destroying_delete_t as an erroneous attempt
16701 // to declare a type aware destroying delete, rather than emitting a
16702 // pile of incorrect parameter type errors.
16704 SemaRef, MD, /*WasMalformed=*/nullptr)) {
16705 QualType AddressParamType =
16707 if (AddressParamType != SemaRef.Context.VoidPtrTy &&
16708 AddressParamType == ConstructDestroyingDeleteAddressType()) {
16709 // The address parameter type implies an author trying to construct a
16710 // type aware destroying delete, so we'll see if we can find a parameter
16711 // of type `std::destroying_delete_t`, and if we find it we'll report
16712 // this as being an attempt at a type aware destroying delete just stop
16713 // here. If we don't do this, the resulting incorrect parameter ordering
16714 // results in a pile mismatched argument type errors that don't explain
16715 // the core problem.
16716 for (auto Param : MD->parameters()) {
16717 if (isDestroyingDeleteT(Param->getType())) {
16718 SemaRef.Diag(MD->getLocation(),
16719 diag::err_type_aware_destroying_operator_delete)
16720 << Param->getSourceRange();
16721 return true;
16722 }
16723 }
16724 }
16725 }
16726
16727 // C++ P0722:
16728 // Within a class C, the first parameter of a destroying operator delete
16729 // shall be of type C *. The first parameter of any other deallocation
16730 // function shall be of type void *.
16731 CanQualType ExpectedAddressParamType =
16736
16737 // C++ [basic.stc.dynamic.deallocation]p2:
16738 // Each deallocation function shall return void
16740 SemaRef, FnDecl, AllocationOperatorKind::Delete,
16741 SemaRef.Context.VoidTy, ExpectedAddressParamType,
16742 diag::err_operator_delete_dependent_param_type,
16743 diag::err_operator_delete_param_type))
16744 return true;
16745
16746 // C++ P0722:
16747 // A destroying operator delete shall be a usual deallocation function.
16748 if (MD && !MD->getParent()->isDependentContext() &&
16751 SemaRef.Diag(MD->getLocation(),
16752 diag::err_destroying_operator_delete_not_usual);
16753 return true;
16754 }
16755 }
16756
16757 return false;
16758}
16759
16761 assert(FnDecl && FnDecl->isOverloadedOperator() &&
16762 "Expected an overloaded operator declaration");
16763
16765
16766 // C++ [over.oper]p5:
16767 // The allocation and deallocation functions, operator new,
16768 // operator new[], operator delete and operator delete[], are
16769 // described completely in 3.7.3. The attributes and restrictions
16770 // found in the rest of this subclause do not apply to them unless
16771 // explicitly stated in 3.7.3.
16772 if (Op == OO_Delete || Op == OO_Array_Delete)
16773 return CheckOperatorDeleteDeclaration(*this, FnDecl);
16774
16775 if (Op == OO_New || Op == OO_Array_New)
16776 return CheckOperatorNewDeclaration(*this, FnDecl);
16777
16778 // C++ [over.oper]p7:
16779 // An operator function shall either be a member function or
16780 // be a non-member function and have at least one parameter
16781 // whose type is a class, a reference to a class, an enumeration,
16782 // or a reference to an enumeration.
16783 // Note: Before C++23, a member function could not be static. The only member
16784 // function allowed to be static is the call operator function.
16785 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
16786 if (MethodDecl->isStatic()) {
16787 if (Op == OO_Call || Op == OO_Subscript)
16788 Diag(FnDecl->getLocation(),
16789 (LangOpts.CPlusPlus23
16790 ? diag::warn_cxx20_compat_operator_overload_static
16791 : diag::ext_operator_overload_static))
16792 << FnDecl;
16793 else
16794 return Diag(FnDecl->getLocation(), diag::err_operator_overload_static)
16795 << FnDecl;
16796 }
16797 } else {
16798 bool ClassOrEnumParam = false;
16799 for (auto *Param : FnDecl->parameters()) {
16800 QualType ParamType = Param->getType().getNonReferenceType();
16801 if (ParamType->isDependentType() || ParamType->isRecordType() ||
16802 ParamType->isEnumeralType()) {
16803 ClassOrEnumParam = true;
16804 break;
16805 }
16806 }
16807
16808 if (!ClassOrEnumParam)
16809 return Diag(FnDecl->getLocation(),
16810 diag::err_operator_overload_needs_class_or_enum)
16811 << FnDecl->getDeclName();
16812 }
16813
16814 // C++ [over.oper]p8:
16815 // An operator function cannot have default arguments (8.3.6),
16816 // except where explicitly stated below.
16817 //
16818 // Only the function-call operator (C++ [over.call]p1) and the subscript
16819 // operator (CWG2507) allow default arguments.
16820 if (Op != OO_Call) {
16821 ParmVarDecl *FirstDefaultedParam = nullptr;
16822 for (auto *Param : FnDecl->parameters()) {
16823 if (Param->hasDefaultArg()) {
16824 FirstDefaultedParam = Param;
16825 break;
16826 }
16827 }
16828 if (FirstDefaultedParam) {
16829 if (Op == OO_Subscript) {
16830 Diag(FnDecl->getLocation(), LangOpts.CPlusPlus23
16831 ? diag::ext_subscript_overload
16832 : diag::error_subscript_overload)
16833 << FnDecl->getDeclName() << 1
16834 << FirstDefaultedParam->getDefaultArgRange();
16835 } else {
16836 return Diag(FirstDefaultedParam->getLocation(),
16837 diag::err_operator_overload_default_arg)
16838 << FnDecl->getDeclName()
16839 << FirstDefaultedParam->getDefaultArgRange();
16840 }
16841 }
16842 }
16843
16844 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
16845 { false, false, false }
16846#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
16847 , { Unary, Binary, MemberOnly }
16848#include "clang/Basic/OperatorKinds.def"
16849 };
16850
16851 bool CanBeUnaryOperator = OperatorUses[Op][0];
16852 bool CanBeBinaryOperator = OperatorUses[Op][1];
16853 bool MustBeMemberOperator = OperatorUses[Op][2];
16854
16855 // C++ [over.oper]p8:
16856 // [...] Operator functions cannot have more or fewer parameters
16857 // than the number required for the corresponding operator, as
16858 // described in the rest of this subclause.
16859 unsigned NumParams = FnDecl->getNumParams() +
16860 (isa<CXXMethodDecl>(FnDecl) &&
16862 ? 1
16863 : 0);
16864 if (Op != OO_Call && Op != OO_Subscript &&
16865 ((NumParams == 1 && !CanBeUnaryOperator) ||
16866 (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) ||
16867 (NumParams > 2))) {
16868 // We have the wrong number of parameters.
16869 unsigned ErrorKind;
16870 if (CanBeUnaryOperator && CanBeBinaryOperator) {
16871 ErrorKind = 2; // 2 -> unary or binary.
16872 } else if (CanBeUnaryOperator) {
16873 ErrorKind = 0; // 0 -> unary
16874 } else {
16875 assert(CanBeBinaryOperator &&
16876 "All non-call overloaded operators are unary or binary!");
16877 ErrorKind = 1; // 1 -> binary
16878 }
16879 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
16880 << FnDecl->getDeclName() << NumParams << ErrorKind;
16881 }
16882
16883 if (Op == OO_Subscript && NumParams != 2) {
16884 Diag(FnDecl->getLocation(), LangOpts.CPlusPlus23
16885 ? diag::ext_subscript_overload
16886 : diag::error_subscript_overload)
16887 << FnDecl->getDeclName() << (NumParams == 1 ? 0 : 2);
16888 }
16889
16890 // Overloaded operators other than operator() and operator[] cannot be
16891 // variadic.
16892 if (Op != OO_Call &&
16893 FnDecl->getType()->castAs<FunctionProtoType>()->isVariadic()) {
16894 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
16895 << FnDecl->getDeclName();
16896 }
16897
16898 // Some operators must be member functions.
16899 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
16900 return Diag(FnDecl->getLocation(),
16901 diag::err_operator_overload_must_be_member)
16902 << FnDecl->getDeclName();
16903 }
16904
16905 // C++ [over.inc]p1:
16906 // The user-defined function called operator++ implements the
16907 // prefix and postfix ++ operator. If this function is a member
16908 // function with no parameters, or a non-member function with one
16909 // parameter of class or enumeration type, it defines the prefix
16910 // increment operator ++ for objects of that type. If the function
16911 // is a member function with one parameter (which shall be of type
16912 // int) or a non-member function with two parameters (the second
16913 // of which shall be of type int), it defines the postfix
16914 // increment operator ++ for objects of that type.
16915 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
16916 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
16917 QualType ParamType = LastParam->getType();
16918
16919 if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
16920 !ParamType->isDependentType())
16921 return Diag(LastParam->getLocation(),
16922 diag::err_operator_overload_post_incdec_must_be_int)
16923 << LastParam->getType() << (Op == OO_MinusMinus);
16924 }
16925
16926 return false;
16927}
16928
16929static bool
16931 FunctionTemplateDecl *TpDecl) {
16932 TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();
16933
16934 // Must have one or two template parameters.
16935 if (TemplateParams->size() == 1) {
16936 NonTypeTemplateParmDecl *PmDecl =
16937 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(0));
16938
16939 // The template parameter must be a char parameter pack.
16940 if (PmDecl && PmDecl->isTemplateParameterPack() &&
16942 return false;
16943
16944 // C++20 [over.literal]p5:
16945 // A string literal operator template is a literal operator template
16946 // whose template-parameter-list comprises a single non-type
16947 // template-parameter of class type.
16948 //
16949 // As a DR resolution, we also allow placeholders for deduced class
16950 // template specializations.
16951 if (SemaRef.getLangOpts().CPlusPlus20 && PmDecl &&
16952 !PmDecl->isTemplateParameterPack() &&
16953 (PmDecl->getType()->isRecordType() ||
16955 return false;
16956 } else if (TemplateParams->size() == 2) {
16957 TemplateTypeParmDecl *PmType =
16958 dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(0));
16959 NonTypeTemplateParmDecl *PmArgs =
16960 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(1));
16961
16962 // The second template parameter must be a parameter pack with the
16963 // first template parameter as its type.
16964 if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
16965 PmArgs->isTemplateParameterPack()) {
16966 if (const auto *TArgs =
16968 TArgs && TArgs->getDepth() == PmType->getDepth() &&
16969 TArgs->getIndex() == PmType->getIndex()) {
16971 SemaRef.Diag(TpDecl->getLocation(),
16972 diag::ext_string_literal_operator_template);
16973 return false;
16974 }
16975 }
16976 }
16977
16979 diag::err_literal_operator_template)
16980 << TpDecl->getTemplateParameters()->getSourceRange();
16981 return true;
16982}
16983
16985 if (isa<CXXMethodDecl>(FnDecl)) {
16986 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
16987 << FnDecl->getDeclName();
16988 return true;
16989 }
16990
16991 if (FnDecl->isExternC()) {
16992 Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
16993 if (const LinkageSpecDecl *LSD =
16994 FnDecl->getDeclContext()->getExternCContext())
16995 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
16996 return true;
16997 }
16998
16999 // This might be the definition of a literal operator template.
17001
17002 // This might be a specialization of a literal operator template.
17003 if (!TpDecl)
17004 TpDecl = FnDecl->getPrimaryTemplate();
17005
17006 // template <char...> type operator "" name() and
17007 // template <class T, T...> type operator "" name() are the only valid
17008 // template signatures, and the only valid signatures with no parameters.
17009 //
17010 // C++20 also allows template <SomeClass T> type operator "" name().
17011 if (TpDecl) {
17012 if (FnDecl->param_size() != 0) {
17013 Diag(FnDecl->getLocation(),
17014 diag::err_literal_operator_template_with_params);
17015 return true;
17016 }
17017
17019 return true;
17020
17021 } else if (FnDecl->param_size() == 1) {
17022 const ParmVarDecl *Param = FnDecl->getParamDecl(0);
17023
17024 QualType ParamType = Param->getType().getUnqualifiedType();
17025
17026 // Only unsigned long long int, long double, any character type, and const
17027 // char * are allowed as the only parameters.
17028 if (ParamType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
17029 ParamType->isSpecificBuiltinType(BuiltinType::LongDouble) ||
17030 Context.hasSameType(ParamType, Context.CharTy) ||
17031 Context.hasSameType(ParamType, Context.WideCharTy) ||
17032 Context.hasSameType(ParamType, Context.Char8Ty) ||
17033 Context.hasSameType(ParamType, Context.Char16Ty) ||
17034 Context.hasSameType(ParamType, Context.Char32Ty)) {
17035 } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
17036 QualType InnerType = Ptr->getPointeeType();
17037
17038 // Pointer parameter must be a const char *.
17039 if (!(Context.hasSameType(InnerType.getUnqualifiedType(),
17040 Context.CharTy) &&
17041 InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
17042 Diag(Param->getSourceRange().getBegin(),
17043 diag::err_literal_operator_param)
17044 << ParamType << "'const char *'" << Param->getSourceRange();
17045 return true;
17046 }
17047
17048 } else if (ParamType->isRealFloatingType()) {
17049 Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
17050 << ParamType << Context.LongDoubleTy << Param->getSourceRange();
17051 return true;
17052
17053 } else if (ParamType->isIntegerType()) {
17054 Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
17055 << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
17056 return true;
17057
17058 } else {
17059 Diag(Param->getSourceRange().getBegin(),
17060 diag::err_literal_operator_invalid_param)
17061 << ParamType << Param->getSourceRange();
17062 return true;
17063 }
17064
17065 } else if (FnDecl->param_size() == 2) {
17066 FunctionDecl::param_iterator Param = FnDecl->param_begin();
17067
17068 // First, verify that the first parameter is correct.
17069
17070 QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
17071
17072 // Two parameter function must have a pointer to const as a
17073 // first parameter; let's strip those qualifiers.
17074 const PointerType *PT = FirstParamType->getAs<PointerType>();
17075
17076 if (!PT) {
17077 Diag((*Param)->getSourceRange().getBegin(),
17078 diag::err_literal_operator_param)
17079 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
17080 return true;
17081 }
17082
17083 QualType PointeeType = PT->getPointeeType();
17084 // First parameter must be const
17085 if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
17086 Diag((*Param)->getSourceRange().getBegin(),
17087 diag::err_literal_operator_param)
17088 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
17089 return true;
17090 }
17091
17092 QualType InnerType = PointeeType.getUnqualifiedType();
17093 // Only const char *, const wchar_t*, const char8_t*, const char16_t*, and
17094 // const char32_t* are allowed as the first parameter to a two-parameter
17095 // function
17096 if (!(Context.hasSameType(InnerType, Context.CharTy) ||
17097 Context.hasSameType(InnerType, Context.WideCharTy) ||
17098 Context.hasSameType(InnerType, Context.Char8Ty) ||
17099 Context.hasSameType(InnerType, Context.Char16Ty) ||
17100 Context.hasSameType(InnerType, Context.Char32Ty))) {
17101 Diag((*Param)->getSourceRange().getBegin(),
17102 diag::err_literal_operator_param)
17103 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
17104 return true;
17105 }
17106
17107 // Move on to the second and final parameter.
17108 ++Param;
17109
17110 // The second parameter must be a std::size_t.
17111 QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
17112 if (!Context.hasSameType(SecondParamType, Context.getSizeType())) {
17113 Diag((*Param)->getSourceRange().getBegin(),
17114 diag::err_literal_operator_param)
17115 << SecondParamType << Context.getSizeType()
17116 << (*Param)->getSourceRange();
17117 return true;
17118 }
17119 } else {
17120 Diag(FnDecl->getLocation(), diag::err_literal_operator_bad_param_count);
17121 return true;
17122 }
17123
17124 // Parameters are good.
17125
17126 // A parameter-declaration-clause containing a default argument is not
17127 // equivalent to any of the permitted forms.
17128 for (auto *Param : FnDecl->parameters()) {
17129 if (Param->hasDefaultArg()) {
17130 Diag(Param->getDefaultArgRange().getBegin(),
17131 diag::err_literal_operator_default_argument)
17132 << Param->getDefaultArgRange();
17133 break;
17134 }
17135 }
17136
17137 const IdentifierInfo *II = FnDecl->getDeclName().getCXXLiteralIdentifier();
17140 !getSourceManager().isInSystemHeader(FnDecl->getLocation())) {
17141 // C++23 [usrlit.suffix]p1:
17142 // Literal suffix identifiers that do not start with an underscore are
17143 // reserved for future standardization. Literal suffix identifiers that
17144 // contain a double underscore __ are reserved for use by C++
17145 // implementations.
17146 Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
17147 << static_cast<int>(Status)
17149 }
17150
17151 return false;
17152}
17153
17155 Expr *LangStr,
17156 SourceLocation LBraceLoc) {
17157 StringLiteral *Lit = cast<StringLiteral>(LangStr);
17158 assert(Lit->isUnevaluated() && "Unexpected string literal kind");
17159
17160 StringRef Lang = Lit->getString();
17162 if (Lang == "C")
17164 else if (Lang == "C++")
17166 else {
17167 Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
17168 << LangStr->getSourceRange();
17169 return nullptr;
17170 }
17171
17172 // FIXME: Add all the various semantics of linkage specifications
17173
17175 LangStr->getExprLoc(), Language,
17176 LBraceLoc.isValid());
17177
17178 /// C++ [module.unit]p7.2.3
17179 /// - Otherwise, if the declaration
17180 /// - ...
17181 /// - ...
17182 /// - appears within a linkage-specification,
17183 /// it is attached to the global module.
17184 ///
17185 /// If the declaration is already in global module fragment, we don't
17186 /// need to attach it again.
17187 if (getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
17188 Module *GlobalModule = PushImplicitGlobalModuleFragment(ExternLoc);
17189 D->setLocalOwningModule(GlobalModule);
17190 }
17191
17193 PushDeclContext(S, D);
17194 return D;
17195}
17196
17198 Decl *LinkageSpec,
17199 SourceLocation RBraceLoc) {
17200 if (RBraceLoc.isValid()) {
17201 LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
17202 LSDecl->setRBraceLoc(RBraceLoc);
17203 }
17204
17205 // If the current module doesn't has Parent, it implies that the
17206 // LinkageSpec isn't in the module created by itself. So we don't
17207 // need to pop it.
17208 if (getLangOpts().CPlusPlusModules && getCurrentModule() &&
17209 getCurrentModule()->isImplicitGlobalModule() &&
17211 PopImplicitGlobalModuleFragment();
17212
17214 return LinkageSpec;
17215}
17216
17218 const ParsedAttributesView &AttrList,
17219 SourceLocation SemiLoc) {
17220 Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
17221 // Attribute declarations appertain to empty declaration so we handle
17222 // them here.
17223 ProcessDeclAttributeList(S, ED, AttrList);
17224
17225 CurContext->addDecl(ED);
17226 return ED;
17227}
17228
17230 SourceLocation StartLoc,
17232 const IdentifierInfo *Name) {
17233 bool Invalid = false;
17234 QualType ExDeclType = TInfo->getType();
17235
17236 // Arrays and functions decay.
17237 if (ExDeclType->isArrayType())
17238 ExDeclType = Context.getArrayDecayedType(ExDeclType);
17239 else if (ExDeclType->isFunctionType())
17240 ExDeclType = Context.getPointerType(ExDeclType);
17241
17242 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
17243 // The exception-declaration shall not denote a pointer or reference to an
17244 // incomplete type, other than [cv] void*.
17245 // N2844 forbids rvalue references.
17246 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
17247 Diag(Loc, diag::err_catch_rvalue_ref);
17248 Invalid = true;
17249 }
17250
17251 if (ExDeclType->isVariablyModifiedType()) {
17252 Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
17253 Invalid = true;
17254 }
17255
17256 QualType BaseType = ExDeclType;
17257 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
17258 unsigned DK = diag::err_catch_incomplete;
17259 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
17260 BaseType = Ptr->getPointeeType();
17261 Mode = 1;
17262 DK = diag::err_catch_incomplete_ptr;
17263 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
17264 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
17265 BaseType = Ref->getPointeeType();
17266 Mode = 2;
17267 DK = diag::err_catch_incomplete_ref;
17268 }
17269 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
17270 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
17271 Invalid = true;
17272
17273 if (!Invalid && BaseType.isWebAssemblyReferenceType()) {
17274 Diag(Loc, diag::err_wasm_reftype_tc) << 1;
17275 Invalid = true;
17276 }
17277
17278 if (!Invalid && Mode != 1 && BaseType->isSizelessType()) {
17279 Diag(Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
17280 Invalid = true;
17281 }
17282
17283 if (!Invalid && !ExDeclType->isDependentType() &&
17284 RequireNonAbstractType(Loc, ExDeclType,
17285 diag::err_abstract_type_in_decl,
17287 Invalid = true;
17288
17289 // Only the non-fragile NeXT runtime currently supports C++ catches
17290 // of ObjC types, and no runtime supports catching ObjC types by value.
17291 if (!Invalid && getLangOpts().ObjC) {
17292 QualType T = ExDeclType;
17293 if (const ReferenceType *RT = T->getAs<ReferenceType>())
17294 T = RT->getPointeeType();
17295
17296 if (T->isObjCObjectType()) {
17297 Diag(Loc, diag::err_objc_object_catch);
17298 Invalid = true;
17299 } else if (T->isObjCObjectPointerType()) {
17300 // FIXME: should this be a test for macosx-fragile specifically?
17302 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
17303 }
17304 }
17305
17306 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
17307 ExDeclType, TInfo, SC_None);
17308 ExDecl->setExceptionVariable(true);
17309
17310 // In ARC, infer 'retaining' for variables of retainable type.
17311 if (getLangOpts().ObjCAutoRefCount && ObjC().inferObjCARCLifetime(ExDecl))
17312 Invalid = true;
17313
17314 if (!Invalid && !ExDeclType->isDependentType()) {
17315 if (auto *ClassDecl = ExDeclType->getAsCXXRecordDecl()) {
17316 // Insulate this from anything else we might currently be parsing.
17319
17320 // C++ [except.handle]p16:
17321 // The object declared in an exception-declaration or, if the
17322 // exception-declaration does not specify a name, a temporary (12.2) is
17323 // copy-initialized (8.5) from the exception object. [...]
17324 // The object is destroyed when the handler exits, after the destruction
17325 // of any automatic objects initialized within the handler.
17326 //
17327 // We just pretend to initialize the object with itself, then make sure
17328 // it can be destroyed later.
17329 QualType initType = Context.getExceptionObjectType(ExDeclType);
17330
17331 InitializedEntity entity =
17333 InitializationKind initKind =
17335
17336 Expr *opaqueValue =
17337 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
17338 InitializationSequence sequence(*this, entity, initKind, opaqueValue);
17339 ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
17340 if (result.isInvalid())
17341 Invalid = true;
17342 else {
17343 // If the constructor used was non-trivial, set this as the
17344 // "initializer".
17345 CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
17346 if (!construct->getConstructor()->isTrivial()) {
17347 Expr *init = MaybeCreateExprWithCleanups(construct);
17348 ExDecl->setInit(init);
17349 }
17350
17351 // And make sure it's destructable.
17352 FinalizeVarWithDestructor(ExDecl, ClassDecl);
17353 }
17354 }
17355 }
17356
17357 if (Invalid)
17358 ExDecl->setInvalidDecl();
17359
17360 return ExDecl;
17361}
17362
17365 bool Invalid = D.isInvalidType();
17366
17367 // Check for unexpanded parameter packs.
17368 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
17371 D.getIdentifierLoc());
17372 Invalid = true;
17373 }
17374
17375 const IdentifierInfo *II = D.getIdentifier();
17376 if (NamedDecl *PrevDecl =
17377 LookupSingleName(S, II, D.getIdentifierLoc(), LookupOrdinaryName,
17378 RedeclarationKind::ForVisibleRedeclaration)) {
17379 // The scope should be freshly made just for us. There is just no way
17380 // it contains any previous declaration, except for function parameters in
17381 // a function-try-block's catch statement.
17382 assert(!S->isDeclScope(PrevDecl));
17383 if (isDeclInScope(PrevDecl, CurContext, S)) {
17384 Diag(D.getIdentifierLoc(), diag::err_redefinition)
17385 << D.getIdentifier();
17386 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
17387 Invalid = true;
17388 } else if (PrevDecl->isTemplateParameter())
17389 // Maybe we will complain about the shadowed template parameter.
17390 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
17391 }
17392
17393 if (D.getCXXScopeSpec().isSet() && !Invalid) {
17394 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
17395 << D.getCXXScopeSpec().getRange();
17396 Invalid = true;
17397 }
17398
17400 S, TInfo, D.getBeginLoc(), D.getIdentifierLoc(), D.getIdentifier());
17401 if (Invalid)
17402 ExDecl->setInvalidDecl();
17403
17404 // Add the exception declaration into this scope.
17405 if (II)
17406 PushOnScopeChains(ExDecl, S);
17407 else
17408 CurContext->addDecl(ExDecl);
17409
17410 ProcessDeclAttributes(S, ExDecl, D);
17411 return ExDecl;
17412}
17413
17415 Expr *AssertExpr,
17416 Expr *AssertMessageExpr,
17417 SourceLocation RParenLoc) {
17419 return nullptr;
17420
17421 return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
17422 AssertMessageExpr, RParenLoc, false);
17423}
17424
17425static void WriteCharTypePrefix(BuiltinType::Kind BTK, llvm::raw_ostream &OS) {
17426 switch (BTK) {
17427 case BuiltinType::Char_S:
17428 case BuiltinType::Char_U:
17429 break;
17430 case BuiltinType::Char8:
17431 OS << "u8";
17432 break;
17433 case BuiltinType::Char16:
17434 OS << 'u';
17435 break;
17436 case BuiltinType::Char32:
17437 OS << 'U';
17438 break;
17439 case BuiltinType::WChar_S:
17440 case BuiltinType::WChar_U:
17441 OS << 'L';
17442 break;
17443 default:
17444 llvm_unreachable("Non-character type");
17445 }
17446}
17447
17448/// Convert character's value, interpreted as a code unit, to a string.
17449/// The value needs to be zero-extended to 32-bits.
17450/// FIXME: This assumes Unicode literal encodings
17451static void WriteCharValueForDiagnostic(uint32_t Value, const BuiltinType *BTy,
17452 unsigned TyWidth,
17453 SmallVectorImpl<char> &Str) {
17454 char Arr[UNI_MAX_UTF8_BYTES_PER_CODE_POINT];
17455 char *Ptr = Arr;
17456 BuiltinType::Kind K = BTy->getKind();
17457 llvm::raw_svector_ostream OS(Str);
17458
17459 // This should catch Char_S, Char_U, Char8, and use of escaped characters in
17460 // other types.
17461 if (K == BuiltinType::Char_S || K == BuiltinType::Char_U ||
17462 K == BuiltinType::Char8 || Value <= 0x7F) {
17463 StringRef Escaped = escapeCStyle<EscapeChar::Single>(Value);
17464 if (!Escaped.empty())
17465 EscapeStringForDiagnostic(Escaped, Str);
17466 else
17467 OS << static_cast<char>(Value);
17468 return;
17469 }
17470
17471 switch (K) {
17472 case BuiltinType::Char16:
17473 case BuiltinType::Char32:
17474 case BuiltinType::WChar_S:
17475 case BuiltinType::WChar_U: {
17476 if (llvm::ConvertCodePointToUTF8(Value, Ptr))
17477 EscapeStringForDiagnostic(StringRef(Arr, Ptr - Arr), Str);
17478 else
17479 OS << "\\x"
17480 << llvm::format_hex_no_prefix(Value, TyWidth / 4, /*Upper=*/true);
17481 break;
17482 }
17483 default:
17484 llvm_unreachable("Non-character type is passed");
17485 }
17486}
17487
17488/// Convert \V to a string we can present to the user in a diagnostic
17489/// \T is the type of the expression that has been evaluated into \V
17493 if (!V.hasValue())
17494 return false;
17495
17496 switch (V.getKind()) {
17498 if (T->isBooleanType()) {
17499 // Bools are reduced to ints during evaluation, but for
17500 // diagnostic purposes we want to print them as
17501 // true or false.
17502 int64_t BoolValue = V.getInt().getExtValue();
17503 assert((BoolValue == 0 || BoolValue == 1) &&
17504 "Bool type, but value is not 0 or 1");
17505 llvm::raw_svector_ostream OS(Str);
17506 OS << (BoolValue ? "true" : "false");
17507 } else {
17508 llvm::raw_svector_ostream OS(Str);
17509 // Same is true for chars.
17510 // We want to print the character representation for textual types
17511 const auto *BTy = T->getAs<BuiltinType>();
17512 if (BTy) {
17513 switch (BTy->getKind()) {
17514 case BuiltinType::Char_S:
17515 case BuiltinType::Char_U:
17516 case BuiltinType::Char8:
17517 case BuiltinType::Char16:
17518 case BuiltinType::Char32:
17519 case BuiltinType::WChar_S:
17520 case BuiltinType::WChar_U: {
17521 unsigned TyWidth = Context.getIntWidth(T);
17522 assert(8 <= TyWidth && TyWidth <= 32 && "Unexpected integer width");
17523 uint32_t CodeUnit = static_cast<uint32_t>(V.getInt().getZExtValue());
17524 WriteCharTypePrefix(BTy->getKind(), OS);
17525 OS << '\'';
17526 WriteCharValueForDiagnostic(CodeUnit, BTy, TyWidth, Str);
17527 OS << "' (0x"
17528 << llvm::format_hex_no_prefix(CodeUnit, /*Width=*/2,
17529 /*Upper=*/true)
17530 << ", " << V.getInt() << ')';
17531 return true;
17532 }
17533 default:
17534 break;
17535 }
17536 }
17537 V.getInt().toString(Str);
17538 }
17539
17540 break;
17541
17543 V.getFloat().toString(Str);
17544 break;
17545
17547 if (V.isNullPointer()) {
17548 llvm::raw_svector_ostream OS(Str);
17549 OS << "nullptr";
17550 } else
17551 return false;
17552 break;
17553
17555 llvm::raw_svector_ostream OS(Str);
17556 OS << '(';
17557 V.getComplexFloatReal().toString(Str);
17558 OS << " + ";
17559 V.getComplexFloatImag().toString(Str);
17560 OS << "i)";
17561 } break;
17562
17564 llvm::raw_svector_ostream OS(Str);
17565 OS << '(';
17566 V.getComplexIntReal().toString(Str);
17567 OS << " + ";
17568 V.getComplexIntImag().toString(Str);
17569 OS << "i)";
17570 } break;
17571
17572 default:
17573 return false;
17574 }
17575
17576 return true;
17577}
17578
17579/// Some Expression types are not useful to print notes about,
17580/// e.g. literals and values that have already been expanded
17581/// before such as int-valued template parameters.
17582static bool UsefulToPrintExpr(const Expr *E) {
17583 E = E->IgnoreParenImpCasts();
17584 // Literals are pretty easy for humans to understand.
17587 return false;
17588
17589 // These have been substituted from template parameters
17590 // and appear as literals in the static assert error.
17591 if (isa<SubstNonTypeTemplateParmExpr>(E))
17592 return false;
17593
17594 // -5 is also simple to understand.
17595 if (const auto *UnaryOp = dyn_cast<UnaryOperator>(E))
17596 return UsefulToPrintExpr(UnaryOp->getSubExpr());
17597
17598 // Only print nested arithmetic operators.
17599 if (const auto *BO = dyn_cast<BinaryOperator>(E))
17600 return (BO->isShiftOp() || BO->isAdditiveOp() || BO->isMultiplicativeOp() ||
17601 BO->isBitwiseOp());
17602
17603 return true;
17604}
17605
17607 if (const auto *Op = dyn_cast<BinaryOperator>(E);
17608 Op && Op->getOpcode() != BO_LOr) {
17609 const Expr *LHS = Op->getLHS()->IgnoreParenImpCasts();
17610 const Expr *RHS = Op->getRHS()->IgnoreParenImpCasts();
17611
17612 // Ignore comparisons of boolean expressions with a boolean literal.
17613 if ((isa<CXXBoolLiteralExpr>(LHS) && RHS->getType()->isBooleanType()) ||
17614 (isa<CXXBoolLiteralExpr>(RHS) && LHS->getType()->isBooleanType()))
17615 return;
17616
17617 // Don't print obvious expressions.
17618 if (!UsefulToPrintExpr(LHS) && !UsefulToPrintExpr(RHS))
17619 return;
17620
17621 struct {
17622 const clang::Expr *Cond;
17624 SmallString<12> ValueString;
17625 bool Print;
17626 } DiagSide[2] = {{LHS, Expr::EvalResult(), {}, false},
17627 {RHS, Expr::EvalResult(), {}, false}};
17628 for (unsigned I = 0; I < 2; I++) {
17629 const Expr *Side = DiagSide[I].Cond;
17630
17631 Side->EvaluateAsRValue(DiagSide[I].Result, Context, true);
17632
17633 DiagSide[I].Print =
17634 ConvertAPValueToString(DiagSide[I].Result.Val, Side->getType(),
17635 DiagSide[I].ValueString, Context);
17636 }
17637 if (DiagSide[0].Print && DiagSide[1].Print) {
17638 Diag(Op->getExprLoc(), diag::note_expr_evaluates_to)
17639 << DiagSide[0].ValueString << Op->getOpcodeStr()
17640 << DiagSide[1].ValueString << Op->getSourceRange();
17641 }
17642 } else {
17644 }
17645}
17646
17647template <typename ResultType>
17648static bool EvaluateAsStringImpl(Sema &SemaRef, Expr *Message,
17649 ResultType &Result, ASTContext &Ctx,
17651 bool ErrorOnInvalidMessage) {
17652
17653 assert(Message);
17654 assert(!Message->isTypeDependent() && !Message->isValueDependent() &&
17655 "can't evaluate a dependant static assert message");
17656
17657 if (const auto *SL = dyn_cast<StringLiteral>(Message)) {
17658 assert(SL->isUnevaluated() && "expected an unevaluated string");
17659 if constexpr (std::is_same_v<APValue, ResultType>) {
17660 Result =
17661 APValue(APValue::UninitArray{}, SL->getLength(), SL->getLength());
17662 const ConstantArrayType *CAT =
17664 assert(CAT && "string literal isn't an array");
17665 QualType CharType = CAT->getElementType();
17666 llvm::APSInt Value(SemaRef.getASTContext().getTypeSize(CharType),
17667 CharType->isUnsignedIntegerType());
17668 for (unsigned I = 0; I < SL->getLength(); I++) {
17669 Value = SL->getCodeUnit(I);
17670 Result.getArrayInitializedElt(I) = APValue(Value);
17671 }
17672 } else {
17673 Result.assign(SL->getString().begin(), SL->getString().end());
17674 }
17675 return true;
17676 }
17677
17678 SourceLocation Loc = Message->getBeginLoc();
17679 QualType T = Message->getType().getNonReferenceType();
17680 auto *RD = T->getAsCXXRecordDecl();
17681 if (!RD) {
17682 SemaRef.Diag(Loc, diag::err_user_defined_msg_invalid) << EvalContext;
17683 return false;
17684 }
17685
17686 auto FindMember = [&](StringRef Member) -> std::optional<LookupResult> {
17688 LookupResult MemberLookup(SemaRef, DN, Loc, Sema::LookupMemberName);
17689 SemaRef.LookupQualifiedName(MemberLookup, RD);
17690 OverloadCandidateSet Candidates(MemberLookup.getNameLoc(),
17692 if (MemberLookup.empty())
17693 return std::nullopt;
17694 return std::move(MemberLookup);
17695 };
17696
17697 std::optional<LookupResult> SizeMember = FindMember("size");
17698 std::optional<LookupResult> DataMember = FindMember("data");
17699 if (!SizeMember || !DataMember) {
17700 SemaRef.Diag(Loc, diag::err_user_defined_msg_missing_member_function)
17701 << EvalContext
17702 << ((!SizeMember && !DataMember) ? 2
17703 : !SizeMember ? 0
17704 : 1);
17705 return false;
17706 }
17707
17708 auto BuildExpr = [&](LookupResult &LR) {
17710 Message, Message->getType(), Message->getBeginLoc(), false,
17711 CXXScopeSpec(), SourceLocation(), nullptr, LR, nullptr, nullptr);
17712 if (Res.isInvalid())
17713 return ExprError();
17714 Res = SemaRef.BuildCallExpr(nullptr, Res.get(), Loc, {}, Loc, nullptr,
17715 false, true);
17716 if (Res.isInvalid())
17717 return ExprError();
17718 if (Res.get()->isTypeDependent() || Res.get()->isValueDependent())
17719 return ExprError();
17721 };
17722
17723 ExprResult SizeE = BuildExpr(*SizeMember);
17724 ExprResult DataE = BuildExpr(*DataMember);
17725
17727 QualType ConstCharPtr = SemaRef.Context.getPointerType(
17729
17730 ExprResult EvaluatedSize =
17731 SizeE.isInvalid()
17732 ? ExprError()
17735 if (EvaluatedSize.isInvalid()) {
17736 SemaRef.Diag(Loc, diag::err_user_defined_msg_invalid_mem_fn_ret_ty)
17737 << EvalContext << /*size*/ 0;
17738 return false;
17739 }
17740
17741 ExprResult EvaluatedData =
17742 DataE.isInvalid()
17743 ? ExprError()
17745 DataE.get(), ConstCharPtr, CCEKind::StaticAssertMessageData);
17746 if (EvaluatedData.isInvalid()) {
17747 SemaRef.Diag(Loc, diag::err_user_defined_msg_invalid_mem_fn_ret_ty)
17748 << EvalContext << /*data*/ 1;
17749 return false;
17750 }
17751
17752 if (!ErrorOnInvalidMessage &&
17753 SemaRef.Diags.isIgnored(diag::warn_user_defined_msg_constexpr, Loc))
17754 return true;
17755
17756 Expr::EvalResult Status;
17758 Status.Diag = &Notes;
17759 if (!Message->EvaluateCharRangeAsString(Result, EvaluatedSize.get(),
17760 EvaluatedData.get(), Ctx, Status) ||
17761 !Notes.empty()) {
17762 SemaRef.Diag(Message->getBeginLoc(),
17763 ErrorOnInvalidMessage ? diag::err_user_defined_msg_constexpr
17764 : diag::warn_user_defined_msg_constexpr)
17765 << EvalContext;
17766 for (const auto &Note : Notes)
17767 SemaRef.Diag(Note.first, Note.second);
17768 return !ErrorOnInvalidMessage;
17769 }
17770 return true;
17771}
17772
17774 StringEvaluationContext EvalContext,
17775 bool ErrorOnInvalidMessage) {
17776 return EvaluateAsStringImpl(*this, Message, Result, Ctx, EvalContext,
17777 ErrorOnInvalidMessage);
17778}
17779
17780bool Sema::EvaluateAsString(Expr *Message, std::string &Result, ASTContext &Ctx,
17781 StringEvaluationContext EvalContext,
17782 bool ErrorOnInvalidMessage) {
17783 return EvaluateAsStringImpl(*this, Message, Result, Ctx, EvalContext,
17784 ErrorOnInvalidMessage);
17785}
17786
17788 Expr *AssertExpr, Expr *AssertMessage,
17789 SourceLocation RParenLoc,
17790 bool Failed) {
17791 assert(AssertExpr != nullptr && "Expected non-null condition");
17792 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
17793 (!AssertMessage || (!AssertMessage->isTypeDependent() &&
17794 !AssertMessage->isValueDependent())) &&
17795 !Failed) {
17796 // In a static_assert-declaration, the constant-expression shall be a
17797 // constant expression that can be contextually converted to bool.
17798 ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
17799 if (Converted.isInvalid())
17800 Failed = true;
17801
17802 ExprResult FullAssertExpr =
17803 ActOnFinishFullExpr(Converted.get(), StaticAssertLoc,
17804 /*DiscardedValue*/ false,
17805 /*IsConstexpr*/ true);
17806 if (FullAssertExpr.isInvalid())
17807 Failed = true;
17808 else
17809 AssertExpr = FullAssertExpr.get();
17810
17811 llvm::APSInt Cond;
17812 Expr *BaseExpr = AssertExpr;
17814
17815 if (!getLangOpts().CPlusPlus) {
17816 // In C mode, allow folding as an extension for better compatibility with
17817 // C++ in terms of expressions like static_assert("test") or
17818 // static_assert(nullptr).
17819 FoldKind = AllowFoldKind::Allow;
17820 }
17821
17822 if (!Failed && VerifyIntegerConstantExpression(
17823 BaseExpr, &Cond,
17824 diag::err_static_assert_expression_is_not_constant,
17825 FoldKind).isInvalid())
17826 Failed = true;
17827
17828 // If the static_assert passes, only verify that
17829 // the message is grammatically valid without evaluating it.
17830 if (!Failed && AssertMessage && Cond.getBoolValue()) {
17831 std::string Str;
17832 EvaluateAsString(AssertMessage, Str, Context,
17834 /*ErrorOnInvalidMessage=*/false);
17835 }
17836
17837 // CWG2518
17838 // [dcl.pre]/p10 If [...] the expression is evaluated in the context of a
17839 // template definition, the declaration has no effect.
17840 bool InTemplateDefinition =
17841 getLangOpts().CPlusPlus && CurContext->isDependentContext();
17842
17843 if (!Failed && !Cond && !InTemplateDefinition) {
17844 SmallString<256> MsgBuffer;
17845 llvm::raw_svector_ostream Msg(MsgBuffer);
17846 bool HasMessage = AssertMessage;
17847 if (AssertMessage) {
17848 std::string Str;
17849 HasMessage = EvaluateAsString(AssertMessage, Str, Context,
17851 /*ErrorOnInvalidMessage=*/true) ||
17852 !Str.empty();
17853 Msg << Str;
17854 }
17855 Expr *InnerCond = nullptr;
17856 std::string InnerCondDescription;
17857 std::tie(InnerCond, InnerCondDescription) =
17858 findFailedBooleanCondition(Converted.get());
17859 if (const auto *ConceptIDExpr =
17860 dyn_cast_or_null<ConceptSpecializationExpr>(InnerCond)) {
17861 // Drill down into concept specialization expressions to see why they
17862 // weren't satisfied.
17863 Diag(AssertExpr->getBeginLoc(), diag::err_static_assert_failed)
17864 << !HasMessage << Msg.str() << AssertExpr->getSourceRange();
17865 ConstraintSatisfaction Satisfaction;
17866 if (!CheckConstraintSatisfaction(ConceptIDExpr, Satisfaction))
17867 DiagnoseUnsatisfiedConstraint(Satisfaction);
17868 } else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond) &&
17869 !isa<IntegerLiteral>(InnerCond)) {
17870 Diag(InnerCond->getBeginLoc(),
17871 diag::err_static_assert_requirement_failed)
17872 << InnerCondDescription << !HasMessage << Msg.str()
17873 << InnerCond->getSourceRange();
17874 DiagnoseStaticAssertDetails(InnerCond);
17875 } else {
17876 Diag(AssertExpr->getBeginLoc(), diag::err_static_assert_failed)
17877 << !HasMessage << Msg.str() << AssertExpr->getSourceRange();
17879 }
17880 Failed = true;
17881 }
17882 } else {
17883 ExprResult FullAssertExpr = ActOnFinishFullExpr(AssertExpr, StaticAssertLoc,
17884 /*DiscardedValue*/false,
17885 /*IsConstexpr*/true);
17886 if (FullAssertExpr.isInvalid())
17887 Failed = true;
17888 else
17889 AssertExpr = FullAssertExpr.get();
17890 }
17891
17893 AssertExpr, AssertMessage, RParenLoc,
17894 Failed);
17895
17897 return Decl;
17898}
17899
17901 Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc,
17902 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
17903 SourceLocation EllipsisLoc, const ParsedAttributesView &Attr,
17904 MultiTemplateParamsArg TempParamLists) {
17906
17907 bool IsMemberSpecialization = false;
17908 bool Invalid = false;
17909
17910 if (TemplateParameterList *TemplateParams =
17912 TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
17913 IsMemberSpecialization, Invalid)) {
17914 if (TemplateParams->size() > 0) {
17915 // This is a declaration of a class template.
17916 if (Invalid)
17917 return true;
17918
17919 return CheckClassTemplate(S, TagSpec, TagUseKind::Friend, TagLoc, SS,
17920 Name, NameLoc, Attr, TemplateParams, AS_public,
17921 /*ModulePrivateLoc=*/SourceLocation(),
17922 FriendLoc, TempParamLists.size() - 1,
17923 TempParamLists.data())
17924 .get();
17925 } else {
17926 // The "template<>" header is extraneous.
17927 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
17928 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
17929 IsMemberSpecialization = true;
17930 }
17931 }
17932
17933 if (Invalid) return true;
17934
17935 bool isAllExplicitSpecializations = true;
17936 for (unsigned I = TempParamLists.size(); I-- > 0; ) {
17937 if (TempParamLists[I]->size()) {
17938 isAllExplicitSpecializations = false;
17939 break;
17940 }
17941 }
17942
17943 // FIXME: don't ignore attributes.
17944
17945 // If it's explicit specializations all the way down, just forget
17946 // about the template header and build an appropriate non-templated
17947 // friend. TODO: for source fidelity, remember the headers.
17949 if (isAllExplicitSpecializations) {
17950 if (SS.isEmpty()) {
17951 bool Owned = false;
17952 bool IsDependent = false;
17953 return ActOnTag(S, TagSpec, TagUseKind::Friend, TagLoc, SS, Name, NameLoc,
17954 Attr, AS_public,
17955 /*ModulePrivateLoc=*/SourceLocation(),
17956 MultiTemplateParamsArg(), Owned, IsDependent,
17957 /*ScopedEnumKWLoc=*/SourceLocation(),
17958 /*ScopedEnumUsesClassTag=*/false,
17959 /*UnderlyingType=*/TypeResult(),
17960 /*IsTypeSpecifier=*/false,
17961 /*IsTemplateParamOrArg=*/false,
17962 /*OOK=*/OffsetOfKind::Outside);
17963 }
17964
17965 TypeSourceInfo *TSI = nullptr;
17968 QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc, *Name,
17969 NameLoc, &TSI, /*DeducedTSTContext=*/true);
17970 if (T.isNull())
17971 return true;
17972
17974 FriendDecl::Create(Context, CurContext, NameLoc, TSI, FriendLoc,
17975 EllipsisLoc, TempParamLists);
17976 Friend->setAccess(AS_public);
17978 return Friend;
17979 }
17980
17981 assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
17982
17983 // CWG 2917: if it (= the friend-type-specifier) is a pack expansion
17984 // (13.7.4 [temp.variadic]), any packs expanded by that pack expansion
17985 // shall not have been introduced by the template-declaration.
17987 collectUnexpandedParameterPacks(QualifierLoc, Unexpanded);
17988 unsigned FriendDeclDepth = TempParamLists.front()->getDepth();
17989 for (UnexpandedParameterPack &U : Unexpanded) {
17990 if (std::optional<std::pair<unsigned, unsigned>> DI = getDepthAndIndex(U);
17991 DI && DI->first >= FriendDeclDepth) {
17992 auto *ND = dyn_cast<NamedDecl *>(U.first);
17993 if (!ND)
17994 ND = cast<const TemplateTypeParmType *>(U.first)->getDecl();
17995 Diag(U.second, diag::friend_template_decl_malformed_pack_expansion)
17996 << ND->getDeclName() << SourceRange(SS.getBeginLoc(), EllipsisLoc);
17997 return true;
17998 }
17999 }
18000
18001 // Handle the case of a templated-scope friend class. e.g.
18002 // template <class T> class A<T>::B;
18003 // FIXME: we don't support these right now.
18004 Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
18005 << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
18010 TL.setElaboratedKeywordLoc(TagLoc);
18012 TL.setNameLoc(NameLoc);
18013
18015 FriendDecl::Create(Context, CurContext, NameLoc, TSI, FriendLoc,
18016 EllipsisLoc, TempParamLists);
18017 Friend->setAccess(AS_public);
18018 Friend->setUnsupportedFriend(true);
18020 return Friend;
18021}
18022
18024 MultiTemplateParamsArg TempParams,
18025 SourceLocation EllipsisLoc) {
18027 SourceLocation FriendLoc = DS.getFriendSpecLoc();
18028
18029 assert(DS.isFriendSpecified());
18031
18032 // C++ [class.friend]p3:
18033 // A friend declaration that does not declare a function shall have one of
18034 // the following forms:
18035 // friend elaborated-type-specifier ;
18036 // friend simple-type-specifier ;
18037 // friend typename-specifier ;
18038 //
18039 // If the friend keyword isn't first, or if the declarations has any type
18040 // qualifiers, then the declaration doesn't have that form.
18042 Diag(FriendLoc, diag::err_friend_not_first_in_declaration);
18043 if (DS.getTypeQualifiers()) {
18045 Diag(DS.getConstSpecLoc(), diag::err_friend_decl_spec) << "const";
18047 Diag(DS.getVolatileSpecLoc(), diag::err_friend_decl_spec) << "volatile";
18049 Diag(DS.getRestrictSpecLoc(), diag::err_friend_decl_spec) << "restrict";
18051 Diag(DS.getAtomicSpecLoc(), diag::err_friend_decl_spec) << "_Atomic";
18053 Diag(DS.getUnalignedSpecLoc(), diag::err_friend_decl_spec) << "__unaligned";
18054 }
18055
18056 // Try to convert the decl specifier to a type. This works for
18057 // friend templates because ActOnTag never produces a ClassTemplateDecl
18058 // for a TagUseKind::Friend.
18059 Declarator TheDeclarator(DS, ParsedAttributesView::none(),
18061 TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator);
18062 QualType T = TSI->getType();
18063 if (TheDeclarator.isInvalidType())
18064 return nullptr;
18065
18066 // If '...' is present, the type must contain an unexpanded parameter
18067 // pack, and vice versa.
18068 bool Invalid = false;
18069 if (EllipsisLoc.isInvalid() &&
18071 return nullptr;
18072 if (EllipsisLoc.isValid() &&
18074 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
18075 << TSI->getTypeLoc().getSourceRange();
18076 Invalid = true;
18077 }
18078
18079 if (!T->isElaboratedTypeSpecifier()) {
18080 if (TempParams.size()) {
18081 // C++23 [dcl.pre]p5:
18082 // In a simple-declaration, the optional init-declarator-list can be
18083 // omitted only when declaring a class or enumeration, that is, when
18084 // the decl-specifier-seq contains either a class-specifier, an
18085 // elaborated-type-specifier with a class-key, or an enum-specifier.
18086 //
18087 // The declaration of a template-declaration or explicit-specialization
18088 // is never a member-declaration, so this must be a simple-declaration
18089 // with no init-declarator-list. Therefore, this is ill-formed.
18090 Diag(Loc, diag::err_tagless_friend_type_template) << DS.getSourceRange();
18091 return nullptr;
18092 } else if (const RecordDecl *RD = T->getAsRecordDecl()) {
18093 SmallString<16> InsertionText(" ");
18094 InsertionText += RD->getKindName();
18095
18097 ? diag::warn_cxx98_compat_unelaborated_friend_type
18098 : diag::ext_unelaborated_friend_type)
18099 << (unsigned)RD->getTagKind() << T
18101 InsertionText);
18102 } else {
18103 DiagCompat(FriendLoc, diag_compat::nonclass_type_friend)
18104 << T << DS.getSourceRange();
18105 }
18106 }
18107
18108 // C++98 [class.friend]p1: A friend of a class is a function
18109 // or class that is not a member of the class . . .
18110 // This is fixed in DR77, which just barely didn't make the C++03
18111 // deadline. It's also a very silly restriction that seriously
18112 // affects inner classes and which nobody else seems to implement;
18113 // thus we never diagnose it, not even in -pedantic.
18114 //
18115 // But note that we could warn about it: it's always useless to
18116 // friend one of your own members (it's not, however, worthless to
18117 // friend a member of an arbitrary specialization of your template).
18118
18119 Decl *D;
18120 if (!TempParams.empty())
18121 // TODO: Support variadic friend template decls?
18122 D = FriendTemplateDecl::Create(Context, CurContext, Loc, TempParams, TSI,
18123 FriendLoc);
18124 else
18126 TSI, FriendLoc, EllipsisLoc);
18127
18128 if (!D)
18129 return nullptr;
18130
18133
18134 if (Invalid)
18135 D->setInvalidDecl();
18136
18137 return D;
18138}
18139
18141 MultiTemplateParamsArg TemplateParams) {
18142 const DeclSpec &DS = D.getDeclSpec();
18143
18144 assert(DS.isFriendSpecified());
18146
18147 SourceLocation Loc = D.getIdentifierLoc();
18149
18150 // C++ [class.friend]p1
18151 // A friend of a class is a function or class....
18152 // Note that this sees through typedefs, which is intended.
18153 // It *doesn't* see through dependent types, which is correct
18154 // according to [temp.arg.type]p3:
18155 // If a declaration acquires a function type through a
18156 // type dependent on a template-parameter and this causes
18157 // a declaration that does not use the syntactic form of a
18158 // function declarator to have a function type, the program
18159 // is ill-formed.
18160 if (!TInfo->getType()->isFunctionType()) {
18161 Diag(Loc, diag::err_unexpected_friend);
18162
18163 // It might be worthwhile to try to recover by creating an
18164 // appropriate declaration.
18165 return nullptr;
18166 }
18167
18168 // C++ [namespace.memdef]p3
18169 // - If a friend declaration in a non-local class first declares a
18170 // class or function, the friend class or function is a member
18171 // of the innermost enclosing namespace.
18172 // - The name of the friend is not found by simple name lookup
18173 // until a matching declaration is provided in that namespace
18174 // scope (either before or after the class declaration granting
18175 // friendship).
18176 // - If a friend function is called, its name may be found by the
18177 // name lookup that considers functions from namespaces and
18178 // classes associated with the types of the function arguments.
18179 // - When looking for a prior declaration of a class or a function
18180 // declared as a friend, scopes outside the innermost enclosing
18181 // namespace scope are not considered.
18182
18183 CXXScopeSpec &SS = D.getCXXScopeSpec();
18185 assert(NameInfo.getName());
18186
18187 // Check for unexpanded parameter packs.
18191 return nullptr;
18192
18193 // The context we found the declaration in, or in which we should
18194 // create the declaration.
18195 DeclContext *DC;
18196 Scope *DCScope = S;
18197 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
18198 RedeclarationKind::ForExternalRedeclaration);
18199
18200 bool isTemplateId = D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId;
18201
18202 // There are five cases here.
18203 // - There's no scope specifier and we're in a local class. Only look
18204 // for functions declared in the immediately-enclosing block scope.
18205 // We recover from invalid scope qualifiers as if they just weren't there.
18206 FunctionDecl *FunctionContainingLocalClass = nullptr;
18207 if ((SS.isInvalid() || !SS.isSet()) &&
18208 (FunctionContainingLocalClass =
18209 cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
18210 // C++11 [class.friend]p11:
18211 // If a friend declaration appears in a local class and the name
18212 // specified is an unqualified name, a prior declaration is
18213 // looked up without considering scopes that are outside the
18214 // innermost enclosing non-class scope. For a friend function
18215 // declaration, if there is no prior declaration, the program is
18216 // ill-formed.
18217
18218 // Find the innermost enclosing non-class scope. This is the block
18219 // scope containing the local class definition (or for a nested class,
18220 // the outer local class).
18221 DCScope = S->getFnParent();
18222
18223 // Look up the function name in the scope.
18225 LookupName(Previous, S, /*AllowBuiltinCreation*/false);
18226
18227 if (!Previous.empty()) {
18228 // All possible previous declarations must have the same context:
18229 // either they were declared at block scope or they are members of
18230 // one of the enclosing local classes.
18231 DC = Previous.getRepresentativeDecl()->getDeclContext();
18232 } else {
18233 // This is ill-formed, but provide the context that we would have
18234 // declared the function in, if we were permitted to, for error recovery.
18235 DC = FunctionContainingLocalClass;
18236 }
18238
18239 // - There's no scope specifier, in which case we just go to the
18240 // appropriate scope and look for a function or function template
18241 // there as appropriate.
18242 } else if (SS.isInvalid() || !SS.isSet()) {
18243 // C++11 [namespace.memdef]p3:
18244 // If the name in a friend declaration is neither qualified nor
18245 // a template-id and the declaration is a function or an
18246 // elaborated-type-specifier, the lookup to determine whether
18247 // the entity has been previously declared shall not consider
18248 // any scopes outside the innermost enclosing namespace.
18249
18250 // Find the appropriate context according to the above.
18251 DC = CurContext;
18252
18253 // Skip class contexts. If someone can cite chapter and verse
18254 // for this behavior, that would be nice --- it's what GCC and
18255 // EDG do, and it seems like a reasonable intent, but the spec
18256 // really only says that checks for unqualified existing
18257 // declarations should stop at the nearest enclosing namespace,
18258 // not that they should only consider the nearest enclosing
18259 // namespace.
18260 while (DC->isRecord())
18261 DC = DC->getParent();
18262
18263 DeclContext *LookupDC = DC->getNonTransparentContext();
18264 while (true) {
18265 LookupQualifiedName(Previous, LookupDC);
18266
18267 if (!Previous.empty()) {
18268 DC = LookupDC;
18269 break;
18270 }
18271
18272 if (isTemplateId) {
18273 if (isa<TranslationUnitDecl>(LookupDC)) break;
18274 } else {
18275 if (LookupDC->isFileContext()) break;
18276 }
18277 LookupDC = LookupDC->getParent();
18278 }
18279
18280 DCScope = getScopeForDeclContext(S, DC);
18281
18282 // - There's a non-dependent scope specifier, in which case we
18283 // compute it and do a previous lookup there for a function
18284 // or function template.
18285 } else if (!SS.getScopeRep().isDependent()) {
18286 DC = computeDeclContext(SS);
18287 if (!DC) return nullptr;
18288
18289 if (RequireCompleteDeclContext(SS, DC)) return nullptr;
18290
18292
18293 // C++ [class.friend]p1: A friend of a class is a function or
18294 // class that is not a member of the class . . .
18295 if (DC->Equals(CurContext))
18298 diag::warn_cxx98_compat_friend_is_member :
18299 diag::err_friend_is_member);
18300
18301 // - There's a scope specifier that does not match any template
18302 // parameter lists, in which case we use some arbitrary context,
18303 // create a method or method template, and wait for instantiation.
18304 // - There's a scope specifier that does match some template
18305 // parameter lists, which we don't handle right now.
18306 } else {
18307 DC = CurContext;
18308 assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
18309 }
18310
18311 if (!DC->isRecord()) {
18312 int DiagArg = -1;
18313 switch (D.getName().getKind()) {
18316 DiagArg = 0;
18317 break;
18319 DiagArg = 1;
18320 break;
18322 DiagArg = 2;
18323 break;
18325 DiagArg = 3;
18326 break;
18332 break;
18333 }
18334 // This implies that it has to be an operator or function.
18335 if (DiagArg >= 0) {
18336 Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
18337 return nullptr;
18338 }
18339 }
18340
18341 // FIXME: This is an egregious hack to cope with cases where the scope stack
18342 // does not contain the declaration context, i.e., in an out-of-line
18343 // definition of a class.
18344 Scope FakeDCScope(S, Scope::DeclScope, Diags);
18345 if (!DCScope) {
18346 FakeDCScope.setEntity(DC);
18347 DCScope = &FakeDCScope;
18348 }
18349
18350 bool AddToScope = true;
18351 NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
18352 TemplateParams, AddToScope);
18353 if (!ND) return nullptr;
18354
18355 assert(ND->getLexicalDeclContext() == CurContext);
18356
18357 // If we performed typo correction, we might have added a scope specifier
18358 // and changed the decl context.
18359 DC = ND->getDeclContext();
18360
18361 // Add the function declaration to the appropriate lookup tables,
18362 // adjusting the redeclarations list as necessary. We don't
18363 // want to do this yet if the friending class is dependent.
18364 //
18365 // Also update the scope-based lookup if the target context's
18366 // lookup context is in lexical scope.
18368 DC = DC->getRedeclContext();
18370 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
18371 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
18372 }
18373
18375 D.getIdentifierLoc(), ND,
18376 DS.getFriendSpecLoc());
18377 FrD->setAccess(AS_public);
18378 CurContext->addDecl(FrD);
18379
18380 if (ND->isInvalidDecl()) {
18381 FrD->setInvalidDecl();
18382 } else {
18383 if (DC->isRecord()) CheckFriendAccess(ND);
18384
18385 FunctionDecl *FD;
18386 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
18387 FD = FTD->getTemplatedDecl();
18388 else
18389 FD = cast<FunctionDecl>(ND);
18390
18391 // C++ [class.friend]p6:
18392 // A function may be defined in a friend declaration of a class if and
18393 // only if the class is a non-local class, and the function name is
18394 // unqualified.
18395 if (D.isFunctionDefinition()) {
18396 // Qualified friend function definition.
18397 if (SS.isNotEmpty()) {
18398 // FIXME: We should only do this if the scope specifier names the
18399 // innermost enclosing namespace; otherwise the fixit changes the
18400 // meaning of the code.
18402 Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
18403
18404 DB << SS.getScopeRep();
18405 if (DC->isFileContext())
18407
18408 // Friend function defined in a local class.
18409 } else if (FunctionContainingLocalClass) {
18410 Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
18411
18412 // Per [basic.pre]p4, a template-id is not a name. Therefore, if we have
18413 // a template-id, the function name is not unqualified because these is
18414 // no name. While the wording requires some reading in-between the
18415 // lines, GCC, MSVC, and EDG all consider a friend function
18416 // specialization definitions to be de facto explicit specialization
18417 // and diagnose them as such.
18418 } else if (isTemplateId) {
18419 Diag(NameInfo.getBeginLoc(), diag::err_friend_specialization_def);
18420 }
18421 }
18422
18423 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
18424 // default argument expression, that declaration shall be a definition
18425 // and shall be the only declaration of the function or function
18426 // template in the translation unit.
18428 // We can't look at FD->getPreviousDecl() because it may not have been set
18429 // if we're in a dependent context. If the function is known to be a
18430 // redeclaration, we will have narrowed Previous down to the right decl.
18431 if (D.isRedeclaration()) {
18432 Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
18433 Diag(Previous.getRepresentativeDecl()->getLocation(),
18434 diag::note_previous_declaration);
18435 } else if (!D.isFunctionDefinition())
18436 Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
18437 }
18438
18439 // Mark templated-scope function declarations as unsupported.
18440 if (FD->getNumTemplateParameterLists() && SS.isValid()) {
18441 Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
18442 << SS.getScopeRep() << SS.getRange()
18443 << cast<CXXRecordDecl>(CurContext);
18444 FrD->setUnsupportedFriend(true);
18445 }
18446 }
18447
18449
18450 return ND;
18451}
18452
18454 StringLiteral *Message) {
18456
18457 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
18458 if (!Fn) {
18459 Diag(DelLoc, diag::err_deleted_non_function);
18460 return;
18461 }
18462
18463 // Deleted function does not have a body.
18464 Fn->setWillHaveBody(false);
18465
18466 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
18467 // Don't consider the implicit declaration we generate for explicit
18468 // specializations. FIXME: Do not generate these implicit declarations.
18469 if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
18470 Prev->getPreviousDecl()) &&
18471 !Prev->isDefined()) {
18472 Diag(DelLoc, diag::err_deleted_decl_not_first);
18473 Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
18474 Prev->isImplicit() ? diag::note_previous_implicit_declaration
18475 : diag::note_previous_declaration);
18476 // We can't recover from this; the declaration might have already
18477 // been used.
18478 Fn->setInvalidDecl();
18479 return;
18480 }
18481
18482 // To maintain the invariant that functions are only deleted on their first
18483 // declaration, mark the implicitly-instantiated declaration of the
18484 // explicitly-specialized function as deleted instead of marking the
18485 // instantiated redeclaration.
18486 Fn = Fn->getCanonicalDecl();
18487 }
18488
18489 // dllimport/dllexport cannot be deleted.
18490 if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
18491 Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
18492 Fn->setInvalidDecl();
18493 }
18494
18495 // C++11 [basic.start.main]p3:
18496 // A program that defines main as deleted [...] is ill-formed.
18497 if (Fn->isMain())
18498 Diag(DelLoc, diag::err_deleted_main);
18499
18500 // C++11 [dcl.fct.def.delete]p4:
18501 // A deleted function is implicitly inline.
18502 Fn->setImplicitlyInline();
18503 Fn->setDeletedAsWritten(true, Message);
18504}
18505
18507 if (!Dcl || Dcl->isInvalidDecl())
18508 return;
18509
18510 auto *FD = dyn_cast<FunctionDecl>(Dcl);
18511 if (!FD) {
18512 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
18513 if (getDefaultedFunctionKind(FTD->getTemplatedDecl()).isComparison()) {
18514 Diag(DefaultLoc, diag::err_defaulted_comparison_template);
18515 return;
18516 }
18517 }
18518
18519 Diag(DefaultLoc, diag::err_default_special_members)
18520 << getLangOpts().CPlusPlus20;
18521 return;
18522 }
18523
18524 // Reject if this can't possibly be a defaultable function.
18526 if (!DefKind &&
18527 // A dependent function that doesn't locally look defaultable can
18528 // still instantiate to a defaultable function if it's a constructor
18529 // or assignment operator.
18530 (!FD->isDependentContext() ||
18531 (!isa<CXXConstructorDecl>(FD) &&
18532 FD->getDeclName().getCXXOverloadedOperator() != OO_Equal))) {
18533 Diag(DefaultLoc, diag::err_default_special_members)
18534 << getLangOpts().CPlusPlus20;
18535 return;
18536 }
18537
18538 // Issue compatibility warning. We already warned if the operator is
18539 // 'operator<=>' when parsing the '<=>' token.
18540 if (DefKind.isComparison() &&
18542 Diag(DefaultLoc, getLangOpts().CPlusPlus20
18543 ? diag::warn_cxx17_compat_defaulted_comparison
18544 : diag::ext_defaulted_comparison);
18545 }
18546
18547 FD->setDefaulted();
18548 FD->setExplicitlyDefaulted();
18549 FD->setDefaultLoc(DefaultLoc);
18550
18551 // Defer checking functions that are defaulted in a dependent context.
18552 if (FD->isDependentContext())
18553 return;
18554
18555 // Unset that we will have a body for this function. We might not,
18556 // if it turns out to be trivial, and we don't need this marking now
18557 // that we've marked it as defaulted.
18558 FD->setWillHaveBody(false);
18559
18560 if (DefKind.isComparison()) {
18561 // If this comparison's defaulting occurs within the definition of its
18562 // lexical class context, we have to do the checking when complete.
18563 if (auto const *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalDeclContext()))
18564 if (!RD->isCompleteDefinition())
18565 return;
18566 }
18567
18568 // If this member fn was defaulted on its first declaration, we will have
18569 // already performed the checking in CheckCompletedCXXClass. Such a
18570 // declaration doesn't trigger an implicit definition.
18571 if (isa<CXXMethodDecl>(FD)) {
18572 const FunctionDecl *Primary = FD;
18573 if (const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
18574 // Ask the template instantiation pattern that actually had the
18575 // '= default' on it.
18576 Primary = Pattern;
18577 if (Primary->getCanonicalDecl()->isDefaulted())
18578 return;
18579 }
18580
18581 if (DefKind.isComparison()) {
18582 if (CheckExplicitlyDefaultedComparison(nullptr, FD, DefKind.asComparison()))
18583 FD->setInvalidDecl();
18584 else
18585 DefineDefaultedComparison(DefaultLoc, FD, DefKind.asComparison());
18586 } else {
18587 auto *MD = cast<CXXMethodDecl>(FD);
18588
18590 DefaultLoc))
18591 MD->setInvalidDecl();
18592 else
18593 DefineDefaultedFunction(*this, MD, DefaultLoc);
18594 }
18595}
18596
18598 for (Stmt *SubStmt : S->children()) {
18599 if (!SubStmt)
18600 continue;
18601 if (isa<ReturnStmt>(SubStmt))
18602 Self.Diag(SubStmt->getBeginLoc(),
18603 diag::err_return_in_constructor_handler);
18604 if (!isa<Expr>(SubStmt))
18605 SearchForReturnInStmt(Self, SubStmt);
18606 }
18607}
18608
18610 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
18611 CXXCatchStmt *Handler = TryBlock->getHandler(I);
18612 SearchForReturnInStmt(*this, Handler);
18613 }
18614}
18615
18617 StringLiteral *DeletedMessage) {
18618 switch (BodyKind) {
18619 case FnBodyKind::Delete:
18620 SetDeclDeleted(D, Loc, DeletedMessage);
18621 break;
18624 break;
18625 case FnBodyKind::Other:
18626 llvm_unreachable(
18627 "Parsed function body should be '= delete;' or '= default;'");
18628 }
18629}
18630
18632 const CXXMethodDecl *Old) {
18633 const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
18634 const auto *OldFT = Old->getType()->castAs<FunctionProtoType>();
18635
18636 if (OldFT->hasExtParameterInfos()) {
18637 for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
18638 // A parameter of the overriding method should be annotated with noescape
18639 // if the corresponding parameter of the overridden method is annotated.
18640 if (OldFT->getExtParameterInfo(I).isNoEscape() &&
18641 !NewFT->getExtParameterInfo(I).isNoEscape()) {
18642 Diag(New->getParamDecl(I)->getLocation(),
18643 diag::warn_overriding_method_missing_noescape);
18644 Diag(Old->getParamDecl(I)->getLocation(),
18645 diag::note_overridden_marked_noescape);
18646 }
18647 }
18648
18649 // SME attributes must match when overriding a function declaration.
18650 if (IsInvalidSMECallConversion(Old->getType(), New->getType())) {
18651 Diag(New->getLocation(), diag::err_conflicting_overriding_attributes)
18652 << New << New->getType() << Old->getType();
18653 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
18654 return true;
18655 }
18656
18657 // Virtual overrides must have the same code_seg.
18658 const auto *OldCSA = Old->getAttr<CodeSegAttr>();
18659 const auto *NewCSA = New->getAttr<CodeSegAttr>();
18660 if ((NewCSA || OldCSA) &&
18661 (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
18662 Diag(New->getLocation(), diag::err_mismatched_code_seg_override);
18663 Diag(Old->getLocation(), diag::note_previous_declaration);
18664 return true;
18665 }
18666
18667 // Virtual overrides: check for matching effects.
18669 const auto OldFX = Old->getFunctionEffects();
18670 const auto NewFXOrig = New->getFunctionEffects();
18671
18672 if (OldFX != NewFXOrig) {
18673 FunctionEffectSet NewFX(NewFXOrig);
18674 const auto Diffs = FunctionEffectDiffVector(OldFX, NewFX);
18676 for (const auto &Diff : Diffs) {
18677 switch (Diff.shouldDiagnoseMethodOverride(*Old, OldFX, *New, NewFX)) {
18679 break;
18681 Diag(New->getLocation(), diag::warn_conflicting_func_effect_override)
18682 << Diff.effectName();
18683 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18684 << Old->getReturnTypeSourceRange();
18685 break;
18687 NewFX.insert(Diff.Old.value(), Errs);
18688 const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
18689 FunctionProtoType::ExtProtoInfo EPI = NewFT->getExtProtoInfo();
18691 QualType ModQT = Context.getFunctionType(NewFT->getReturnType(),
18692 NewFT->getParamTypes(), EPI);
18693 New->setType(ModQT);
18694 if (Errs.empty()) {
18695 // A warning here is somewhat pedantic. Skip this if there was
18696 // already a merge conflict, which is more serious.
18697 Diag(New->getLocation(), diag::warn_mismatched_func_effect_override)
18698 << Diff.effectName();
18699 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18700 << Old->getReturnTypeSourceRange();
18701 }
18702 break;
18703 }
18704 }
18705 }
18706 if (!Errs.empty())
18707 diagnoseFunctionEffectMergeConflicts(Errs, New->getLocation(),
18708 Old->getLocation());
18709 }
18710 }
18711
18712 CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
18713
18714 // If the calling conventions match, everything is fine
18715 if (NewCC == OldCC)
18716 return false;
18717
18718 // If the calling conventions mismatch because the new function is static,
18719 // suppress the calling convention mismatch error; the error about static
18720 // function override (err_static_overrides_virtual from
18721 // Sema::CheckFunctionDeclaration) is more clear.
18722 if (New->getStorageClass() == SC_Static)
18723 return false;
18724
18725 Diag(New->getLocation(),
18726 diag::err_conflicting_overriding_cc_attributes)
18727 << New->getDeclName() << New->getType() << Old->getType();
18728 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
18729 return true;
18730}
18731
18733 const CXXMethodDecl *Old) {
18734 // CWG2553
18735 // A virtual function shall not be an explicit object member function.
18736 if (!New->isExplicitObjectMemberFunction())
18737 return true;
18738 Diag(New->getParamDecl(0)->getBeginLoc(),
18739 diag::err_explicit_object_parameter_nonmember)
18740 << New->getSourceRange() << /*virtual*/ 1 << /*IsLambda*/ false;
18741 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
18742 New->setInvalidDecl();
18743 return false;
18744}
18745
18747 const CXXMethodDecl *Old) {
18748 QualType NewTy = New->getType()->castAs<FunctionType>()->getReturnType();
18749 QualType OldTy = Old->getType()->castAs<FunctionType>()->getReturnType();
18750
18751 if (Context.hasSameType(NewTy, OldTy) ||
18752 NewTy->isDependentType() || OldTy->isDependentType())
18753 return false;
18754
18755 // Check if the return types are covariant
18756 QualType NewClassTy, OldClassTy;
18757
18758 /// Both types must be pointers or references to classes.
18759 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
18760 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
18761 NewClassTy = NewPT->getPointeeType();
18762 OldClassTy = OldPT->getPointeeType();
18763 }
18764 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
18765 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
18766 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
18767 NewClassTy = NewRT->getPointeeType();
18768 OldClassTy = OldRT->getPointeeType();
18769 }
18770 }
18771 }
18772
18773 // The return types aren't either both pointers or references to a class type.
18774 if (NewClassTy.isNull() || !NewClassTy->isStructureOrClassType()) {
18775 Diag(New->getLocation(),
18776 diag::err_different_return_type_for_overriding_virtual_function)
18777 << New->getDeclName() << NewTy << OldTy
18778 << New->getReturnTypeSourceRange();
18779 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18780 << Old->getReturnTypeSourceRange();
18781
18782 return true;
18783 }
18784
18785 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
18786 // C++14 [class.virtual]p8:
18787 // If the class type in the covariant return type of D::f differs from
18788 // that of B::f, the class type in the return type of D::f shall be
18789 // complete at the point of declaration of D::f or shall be the class
18790 // type D.
18791 if (const auto *RD = NewClassTy->getAsCXXRecordDecl()) {
18792 if (!RD->isBeingDefined() &&
18793 RequireCompleteType(New->getLocation(), NewClassTy,
18794 diag::err_covariant_return_incomplete,
18795 New->getDeclName()))
18796 return true;
18797 }
18798
18799 // Check if the new class derives from the old class.
18800 if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
18801 Diag(New->getLocation(), diag::err_covariant_return_not_derived)
18802 << New->getDeclName() << NewTy << OldTy
18803 << New->getReturnTypeSourceRange();
18804 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18805 << Old->getReturnTypeSourceRange();
18806 return true;
18807 }
18808
18809 // Check if we the conversion from derived to base is valid.
18811 NewClassTy, OldClassTy,
18812 diag::err_covariant_return_inaccessible_base,
18813 diag::err_covariant_return_ambiguous_derived_to_base_conv,
18814 New->getLocation(), New->getReturnTypeSourceRange(),
18815 New->getDeclName(), nullptr)) {
18816 // FIXME: this note won't trigger for delayed access control
18817 // diagnostics, and it's impossible to get an undelayed error
18818 // here from access control during the original parse because
18819 // the ParsingDeclSpec/ParsingDeclarator are still in scope.
18820 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18821 << Old->getReturnTypeSourceRange();
18822 return true;
18823 }
18824 }
18825
18826 // The qualifiers of the return types must be the same.
18827 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
18828 Diag(New->getLocation(),
18829 diag::err_covariant_return_type_different_qualifications)
18830 << New->getDeclName() << NewTy << OldTy
18831 << New->getReturnTypeSourceRange();
18832 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18833 << Old->getReturnTypeSourceRange();
18834 return true;
18835 }
18836
18837
18838 // The new class type must have the same or less qualifiers as the old type.
18839 if (!OldClassTy.isAtLeastAsQualifiedAs(NewClassTy, getASTContext())) {
18840 Diag(New->getLocation(),
18841 diag::err_covariant_return_type_class_type_not_same_or_less_qualified)
18842 << New->getDeclName() << NewTy << OldTy
18843 << New->getReturnTypeSourceRange();
18844 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18845 << Old->getReturnTypeSourceRange();
18846 return true;
18847 }
18848
18849 return false;
18850}
18851
18853 SourceLocation EndLoc = InitRange.getEnd();
18854 if (EndLoc.isValid())
18855 Method->setRangeEnd(EndLoc);
18856
18857 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
18858 Method->setIsPureVirtual();
18859 return false;
18860 }
18861
18862 if (!Method->isInvalidDecl())
18863 Diag(Method->getLocation(), diag::err_non_virtual_pure)
18864 << Method->getDeclName() << InitRange;
18865 return true;
18866}
18867
18869 if (D->getFriendObjectKind())
18870 Diag(D->getLocation(), diag::err_pure_friend);
18871 else if (auto *M = dyn_cast<CXXMethodDecl>(D))
18872 CheckPureMethod(M, ZeroLoc);
18873 else
18874 Diag(D->getLocation(), diag::err_illegal_initializer);
18875}
18876
18877/// Invoked when we are about to parse an initializer for the declaration
18878/// 'Dcl'.
18879///
18880/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
18881/// static data member of class X, names should be looked up in the scope of
18882/// class X. If the declaration had a scope specifier, a scope will have
18883/// been created and passed in for this purpose. Otherwise, S will be null.
18885 assert(D && !D->isInvalidDecl());
18886
18887 // We will always have a nested name specifier here, but this declaration
18888 // might not be out of line if the specifier names the current namespace:
18889 // extern int n;
18890 // int ::n = 0;
18891 if (S && D->isOutOfLine())
18893
18897}
18898
18900 assert(D);
18901
18902 if (S && D->isOutOfLine())
18904
18906}
18907
18909 // C++ 6.4p2:
18910 // The declarator shall not specify a function or an array.
18911 // The type-specifier-seq shall not contain typedef and shall not declare a
18912 // new class or enumeration.
18913 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
18914 "Parser allowed 'typedef' as storage class of condition decl.");
18915
18916 Decl *Dcl = ActOnDeclarator(S, D);
18917 if (!Dcl)
18918 return true;
18919
18920 if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
18921 Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
18922 << D.getSourceRange();
18923 return true;
18924 }
18925
18926 if (auto *VD = dyn_cast<VarDecl>(Dcl))
18927 VD->setCXXCondDecl();
18928
18929 return Dcl;
18930}
18931
18933 if (!ExternalSource)
18934 return;
18935
18937 ExternalSource->ReadUsedVTables(VTables);
18939 for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
18940 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
18941 = VTablesUsed.find(VTables[I].Record);
18942 // Even if a definition wasn't required before, it may be required now.
18943 if (Pos != VTablesUsed.end()) {
18944 if (!Pos->second && VTables[I].DefinitionRequired)
18945 Pos->second = true;
18946 continue;
18947 }
18948
18949 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
18950 NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
18951 }
18952
18953 VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
18954}
18955
18957 bool DefinitionRequired) {
18958 // Ignore any vtable uses in unevaluated operands or for classes that do
18959 // not have a vtable.
18960 if (!Class->isDynamicClass() || Class->isDependentContext() ||
18962 return;
18963 // Do not mark as used if compiling for the device outside of the target
18964 // region.
18965 if (TUKind != TU_Prefix && LangOpts.OpenMP && LangOpts.OpenMPIsTargetDevice &&
18966 !OpenMP().isInOpenMPDeclareTargetContext() &&
18967 !OpenMP().isInOpenMPTargetExecutionDirective()) {
18968 if (!DefinitionRequired)
18970 return;
18971 }
18972
18973 // Try to insert this class into the map.
18975 Class = Class->getCanonicalDecl();
18976 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
18977 Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
18978 if (!Pos.second) {
18979 // If we already had an entry, check to see if we are promoting this vtable
18980 // to require a definition. If so, we need to reappend to the VTableUses
18981 // list, since we may have already processed the first entry.
18982 if (DefinitionRequired && !Pos.first->second) {
18983 Pos.first->second = true;
18984 } else {
18985 // Otherwise, we can early exit.
18986 return;
18987 }
18988 } else {
18989 // The Microsoft ABI requires that we perform the destructor body
18990 // checks (i.e. operator delete() lookup) when the vtable is marked used, as
18991 // the deleting destructor is emitted with the vtable, not with the
18992 // destructor definition as in the Itanium ABI.
18994 CXXDestructorDecl *DD = Class->getDestructor();
18995 if (DD && DD->isVirtual() && !DD->isDeleted()) {
18996 if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
18997 // If this is an out-of-line declaration, marking it referenced will
18998 // not do anything. Manually call CheckDestructor to look up operator
18999 // delete().
19000 ContextRAII SavedContext(*this, DD);
19001 CheckDestructor(DD);
19002 } else {
19003 MarkFunctionReferenced(Loc, Class->getDestructor());
19004 }
19005 }
19006 }
19007 }
19008
19009 // Local classes need to have their virtual members marked
19010 // immediately. For all other classes, we mark their virtual members
19011 // at the end of the translation unit.
19012 if (Class->isLocalClass())
19013 MarkVirtualMembersReferenced(Loc, Class->getDefinition());
19014 else
19015 VTableUses.push_back(std::make_pair(Class, Loc));
19016}
19017
19020 if (VTableUses.empty())
19021 return false;
19022
19023 // Note: The VTableUses vector could grow as a result of marking
19024 // the members of a class as "used", so we check the size each
19025 // time through the loop and prefer indices (which are stable) to
19026 // iterators (which are not).
19027 bool DefinedAnything = false;
19028 for (unsigned I = 0; I != VTableUses.size(); ++I) {
19029 CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
19030 if (!Class)
19031 continue;
19033 Class->getTemplateSpecializationKind();
19034
19035 SourceLocation Loc = VTableUses[I].second;
19036
19037 bool DefineVTable = true;
19038
19039 const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
19040 // V-tables for non-template classes with an owning module are always
19041 // uniquely emitted in that module.
19042 if (Class->isInCurrentModuleUnit()) {
19043 DefineVTable = true;
19044 } else if (KeyFunction && !KeyFunction->hasBody()) {
19045 // If this class has a key function, but that key function is
19046 // defined in another translation unit, we don't need to emit the
19047 // vtable even though we're using it.
19048 // The key function is in another translation unit.
19049 DefineVTable = false;
19051 KeyFunction->getTemplateSpecializationKind();
19054 "Instantiations don't have key functions");
19055 (void)TSK;
19056 } else if (!KeyFunction) {
19057 // If we have a class with no key function that is the subject
19058 // of an explicit instantiation declaration, suppress the
19059 // vtable; it will live with the explicit instantiation
19060 // definition.
19061 bool IsExplicitInstantiationDeclaration =
19063 for (auto *R : Class->redecls()) {
19065 = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
19067 IsExplicitInstantiationDeclaration = true;
19068 else if (TSK == TSK_ExplicitInstantiationDefinition) {
19069 IsExplicitInstantiationDeclaration = false;
19070 break;
19071 }
19072 }
19073
19074 if (IsExplicitInstantiationDeclaration)
19075 DefineVTable = false;
19076 }
19077
19078 // The exception specifications for all virtual members may be needed even
19079 // if we are not providing an authoritative form of the vtable in this TU.
19080 // We may choose to emit it available_externally anyway.
19081 if (!DefineVTable) {
19083 continue;
19084 }
19085
19086 // Mark all of the virtual members of this class as referenced, so
19087 // that we can build a vtable. Then, tell the AST consumer that a
19088 // vtable for this class is required.
19089 DefinedAnything = true;
19091 CXXRecordDecl *Canonical = Class->getCanonicalDecl();
19092 if (VTablesUsed[Canonical] && !Class->shouldEmitInExternalSource())
19094
19095 // Warn if we're emitting a weak vtable. The vtable will be weak if there is
19096 // no key function or the key function is inlined. Don't warn in C++ ABIs
19097 // that lack key functions, since the user won't be able to make one.
19099 Class->isExternallyVisible() && ClassTSK != TSK_ImplicitInstantiation &&
19101 const FunctionDecl *KeyFunctionDef = nullptr;
19102 if (!KeyFunction || (KeyFunction->hasBody(KeyFunctionDef) &&
19103 KeyFunctionDef->isInlined()))
19104 Diag(Class->getLocation(), diag::warn_weak_vtable) << Class;
19105 }
19106 }
19107 VTableUses.clear();
19108
19109 return DefinedAnything;
19110}
19111
19113 const CXXRecordDecl *RD) {
19114 for (const auto *I : RD->methods())
19115 if (I->isVirtual() && !I->isPureVirtual())
19116 ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
19117}
19118
19120 const CXXRecordDecl *RD,
19121 bool ConstexprOnly) {
19122 // Mark all functions which will appear in RD's vtable as used.
19123 CXXFinalOverriderMap FinalOverriders;
19124 RD->getFinalOverriders(FinalOverriders);
19125 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
19126 E = FinalOverriders.end();
19127 I != E; ++I) {
19128 for (OverridingMethods::const_iterator OI = I->second.begin(),
19129 OE = I->second.end();
19130 OI != OE; ++OI) {
19131 assert(OI->second.size() > 0 && "no final overrider");
19132 CXXMethodDecl *Overrider = OI->second.front().Method;
19133
19134 // C++ [basic.def.odr]p2:
19135 // [...] A virtual member function is used if it is not pure. [...]
19136 if (!Overrider->isPureVirtual() &&
19137 (!ConstexprOnly || Overrider->isConstexpr()))
19138 MarkFunctionReferenced(Loc, Overrider);
19139 }
19140 }
19141
19142 // Only classes that have virtual bases need a VTT.
19143 if (RD->getNumVBases() == 0)
19144 return;
19145
19146 for (const auto &I : RD->bases()) {
19147 const auto *Base = I.getType()->castAsCXXRecordDecl();
19148 if (Base->getNumVBases() == 0)
19149 continue;
19151 }
19152}
19153
19154static
19159 Sema &S) {
19160 if (Ctor->isInvalidDecl())
19161 return;
19162
19164
19165 // Target may not be determinable yet, for instance if this is a dependent
19166 // call in an uninstantiated template.
19167 if (Target) {
19168 const FunctionDecl *FNTarget = nullptr;
19169 (void)Target->hasBody(FNTarget);
19170 Target = const_cast<CXXConstructorDecl*>(
19171 cast_or_null<CXXConstructorDecl>(FNTarget));
19172 }
19173
19174 CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
19175 // Avoid dereferencing a null pointer here.
19176 *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
19177
19178 if (!Current.insert(Canonical).second)
19179 return;
19180
19181 // We know that beyond here, we aren't chaining into a cycle.
19182 if (!Target || !Target->isDelegatingConstructor() ||
19183 Target->isInvalidDecl() || Valid.count(TCanonical)) {
19184 Valid.insert_range(Current);
19185 Current.clear();
19186 // We've hit a cycle.
19187 } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
19188 Current.count(TCanonical)) {
19189 // If we haven't diagnosed this cycle yet, do so now.
19190 if (!Invalid.count(TCanonical)) {
19191 S.Diag((*Ctor->init_begin())->getSourceLocation(),
19192 diag::warn_delegating_ctor_cycle)
19193 << Ctor;
19194
19195 // Don't add a note for a function delegating directly to itself.
19196 if (TCanonical != Canonical)
19197 S.Diag(Target->getLocation(), diag::note_it_delegates_to);
19198
19200 while (C->getCanonicalDecl() != Canonical) {
19201 const FunctionDecl *FNTarget = nullptr;
19202 (void)C->getTargetConstructor()->hasBody(FNTarget);
19203 assert(FNTarget && "Ctor cycle through bodiless function");
19204
19205 C = const_cast<CXXConstructorDecl*>(
19206 cast<CXXConstructorDecl>(FNTarget));
19207 S.Diag(C->getLocation(), diag::note_which_delegates_to);
19208 }
19209 }
19210
19211 Invalid.insert_range(Current);
19212 Current.clear();
19213 } else {
19215 }
19216}
19217
19218
19221
19222 for (DelegatingCtorDeclsType::iterator
19225 I != E; ++I)
19226 DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
19227
19228 for (auto CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI)
19229 (*CI)->setInvalidDecl();
19230}
19231
19232namespace {
19233 /// AST visitor that finds references to the 'this' expression.
19234class FindCXXThisExpr : public DynamicRecursiveASTVisitor {
19235 Sema &S;
19236
19237public:
19238 explicit FindCXXThisExpr(Sema &S) : S(S) {}
19239
19240 bool VisitCXXThisExpr(CXXThisExpr *E) override {
19241 S.Diag(E->getLocation(), diag::err_this_static_member_func)
19242 << E->isImplicit();
19243 return false;
19244 }
19245};
19246}
19247
19249 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
19250 if (!TSInfo)
19251 return false;
19252
19253 TypeLoc TL = TSInfo->getTypeLoc();
19255 if (!ProtoTL)
19256 return false;
19257
19258 // C++11 [expr.prim.general]p3:
19259 // [The expression this] shall not appear before the optional
19260 // cv-qualifier-seq and it shall not appear within the declaration of a
19261 // static member function (although its type and value category are defined
19262 // within a static member function as they are within a non-static member
19263 // function). [ Note: this is because declaration matching does not occur
19264 // until the complete declarator is known. - end note ]
19265 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
19266 FindCXXThisExpr Finder(*this);
19267
19268 // If the return type came after the cv-qualifier-seq, check it now.
19269 if (Proto->hasTrailingReturn() &&
19270 !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
19271 return true;
19272
19273 // Check the exception specification.
19275 return true;
19276
19277 // Check the trailing requires clause
19278 if (const AssociatedConstraint &TRC = Method->getTrailingRequiresClause())
19279 if (!Finder.TraverseStmt(const_cast<Expr *>(TRC.ConstraintExpr)))
19280 return true;
19281
19283}
19284
19286 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
19287 if (!TSInfo)
19288 return false;
19289
19290 TypeLoc TL = TSInfo->getTypeLoc();
19292 if (!ProtoTL)
19293 return false;
19294
19295 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
19296 FindCXXThisExpr Finder(*this);
19297
19298 switch (Proto->getExceptionSpecType()) {
19299 case EST_Unparsed:
19300 case EST_Uninstantiated:
19301 case EST_Unevaluated:
19302 case EST_BasicNoexcept:
19303 case EST_NoThrow:
19304 case EST_DynamicNone:
19305 case EST_MSAny:
19306 case EST_None:
19307 break;
19308
19310 case EST_NoexceptFalse:
19311 case EST_NoexceptTrue:
19312 if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
19313 return true;
19314 [[fallthrough]];
19315
19316 case EST_Dynamic:
19317 for (const auto &E : Proto->exceptions()) {
19318 if (!Finder.TraverseType(E))
19319 return true;
19320 }
19321 break;
19322 }
19323
19324 return false;
19325}
19326
19328 FindCXXThisExpr Finder(*this);
19329
19330 // Check attributes.
19331 for (const auto *A : Method->attrs()) {
19332 // FIXME: This should be emitted by tblgen.
19333 Expr *Arg = nullptr;
19334 ArrayRef<Expr *> Args;
19335 if (const auto *G = dyn_cast<GuardedByAttr>(A))
19336 Arg = G->getArg();
19337 else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
19338 Arg = G->getArg();
19339 else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
19340 Args = llvm::ArrayRef(AA->args_begin(), AA->args_size());
19341 else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
19342 Args = llvm::ArrayRef(AB->args_begin(), AB->args_size());
19343 else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
19344 Arg = LR->getArg();
19345 else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
19346 Args = llvm::ArrayRef(LE->args_begin(), LE->args_size());
19347 else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
19348 Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
19349 else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
19350 Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
19351 else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A)) {
19352 Arg = AC->getSuccessValue();
19353 Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
19354 } else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
19355 Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
19356
19357 if (Arg && !Finder.TraverseStmt(Arg))
19358 return true;
19359
19360 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
19361 if (!Finder.TraverseStmt(Args[I]))
19362 return true;
19363 }
19364 }
19365
19366 return false;
19367}
19368
19370 bool IsTopLevel, ExceptionSpecificationType EST,
19371 ArrayRef<ParsedType> DynamicExceptions,
19372 ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
19373 SmallVectorImpl<QualType> &Exceptions,
19375 Exceptions.clear();
19376 ESI.Type = EST;
19377 if (EST == EST_Dynamic) {
19378 Exceptions.reserve(DynamicExceptions.size());
19379 for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
19380 // FIXME: Preserve type source info.
19381 QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
19382
19383 if (IsTopLevel) {
19385 collectUnexpandedParameterPacks(ET, Unexpanded);
19386 if (!Unexpanded.empty()) {
19388 DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
19389 Unexpanded);
19390 continue;
19391 }
19392 }
19393
19394 // Check that the type is valid for an exception spec, and
19395 // drop it if not.
19396 if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
19397 Exceptions.push_back(ET);
19398 }
19399 ESI.Exceptions = Exceptions;
19400 return;
19401 }
19402
19403 if (isComputedNoexcept(EST)) {
19404 assert((NoexceptExpr->isTypeDependent() ||
19405 NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
19406 Context.BoolTy) &&
19407 "Parser should have made sure that the expression is boolean");
19408 if (IsTopLevel && DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
19409 ESI.Type = EST_BasicNoexcept;
19410 return;
19411 }
19412
19413 ESI.NoexceptExpr = NoexceptExpr;
19414 return;
19415 }
19416}
19417
19419 Decl *D, ExceptionSpecificationType EST, SourceRange SpecificationRange,
19420 ArrayRef<ParsedType> DynamicExceptions,
19421 ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr) {
19422 if (!D)
19423 return;
19424
19425 // Dig out the function we're referring to.
19426 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
19427 D = FTD->getTemplatedDecl();
19428
19429 FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
19430 if (!FD)
19431 return;
19432
19433 // Check the exception specification.
19436 checkExceptionSpecification(/*IsTopLevel=*/true, EST, DynamicExceptions,
19437 DynamicExceptionRanges, NoexceptExpr, Exceptions,
19438 ESI);
19439
19440 // Update the exception specification on the function type.
19441 Context.adjustExceptionSpec(FD, ESI, /*AsWritten=*/true);
19442
19443 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
19444 if (MD->isStatic())
19446
19447 if (MD->isVirtual()) {
19448 // Check overrides, which we previously had to delay.
19449 for (const CXXMethodDecl *O : MD->overridden_methods())
19451 }
19452 }
19453}
19454
19455/// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
19456///
19458 SourceLocation DeclStart, Declarator &D,
19459 Expr *BitWidth,
19460 InClassInitStyle InitStyle,
19461 AccessSpecifier AS,
19462 const ParsedAttr &MSPropertyAttr) {
19463 const IdentifierInfo *II = D.getIdentifier();
19464 if (!II) {
19465 Diag(DeclStart, diag::err_anonymous_property);
19466 return nullptr;
19467 }
19468 SourceLocation Loc = D.getIdentifierLoc();
19469
19471 QualType T = TInfo->getType();
19472 if (getLangOpts().CPlusPlus) {
19474
19475 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
19477 D.setInvalidType();
19478 T = Context.IntTy;
19480 }
19481 }
19482
19483 DiagnoseFunctionSpecifiers(D.getDeclSpec());
19484
19485 if (D.getDeclSpec().isInlineSpecified())
19486 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
19487 << getLangOpts().CPlusPlus17;
19488 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
19489 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
19490 diag::err_invalid_thread)
19492
19493 // Check to see if this name was declared as a member previously
19494 NamedDecl *PrevDecl = nullptr;
19496 RedeclarationKind::ForVisibleRedeclaration);
19497 LookupName(Previous, S);
19498 switch (Previous.getResultKind()) {
19501 PrevDecl = Previous.getAsSingle<NamedDecl>();
19502 break;
19503
19505 PrevDecl = Previous.getRepresentativeDecl();
19506 break;
19507
19511 break;
19512 }
19513
19514 if (PrevDecl && PrevDecl->isTemplateParameter()) {
19515 // Maybe we will complain about the shadowed template parameter.
19516 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
19517 // Just pretend that we didn't see the previous declaration.
19518 PrevDecl = nullptr;
19519 }
19520
19521 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
19522 PrevDecl = nullptr;
19523
19524 SourceLocation TSSL = D.getBeginLoc();
19525 MSPropertyDecl *NewPD =
19526 MSPropertyDecl::Create(Context, Record, Loc, II, T, TInfo, TSSL,
19527 MSPropertyAttr.getPropertyDataGetter(),
19528 MSPropertyAttr.getPropertyDataSetter());
19530 NewPD->setAccess(AS);
19531
19532 if (NewPD->isInvalidDecl())
19533 Record->setInvalidDecl();
19534
19535 if (D.getDeclSpec().isModulePrivateSpecified())
19536 NewPD->setModulePrivate();
19537
19538 if (NewPD->isInvalidDecl() && PrevDecl) {
19539 // Don't introduce NewFD into scope; there's already something
19540 // with the same name in the same scope.
19541 } else if (II) {
19542 PushOnScopeChains(NewPD, S);
19543 } else
19544 Record->addDecl(NewPD);
19545
19546 return NewPD;
19547}
19548
19550 Declarator &Declarator, unsigned TemplateParameterDepth) {
19551 auto &Info = InventedParameterInfos.emplace_back();
19552 TemplateParameterList *ExplicitParams = nullptr;
19553 ArrayRef<TemplateParameterList *> ExplicitLists =
19555 if (!ExplicitLists.empty()) {
19556 bool IsMemberSpecialization, IsInvalid;
19559 Declarator.getCXXScopeSpec(), /*TemplateId=*/nullptr,
19560 ExplicitLists, /*IsFriend=*/false, IsMemberSpecialization, IsInvalid,
19561 /*SuppressDiagnostic=*/true);
19562 }
19563 // C++23 [dcl.fct]p23:
19564 // An abbreviated function template can have a template-head. The invented
19565 // template-parameters are appended to the template-parameter-list after
19566 // the explicitly declared template-parameters.
19567 //
19568 // A template-head must have one or more template-parameters (read:
19569 // 'template<>' is *not* a template-head). Only append the invented
19570 // template parameters if we matched the nested-name-specifier to a non-empty
19571 // TemplateParameterList.
19572 if (ExplicitParams && !ExplicitParams->empty()) {
19573 Info.AutoTemplateParameterDepth = ExplicitParams->getDepth();
19574 llvm::append_range(Info.TemplateParams, *ExplicitParams);
19575 Info.NumExplicitTemplateParams = ExplicitParams->size();
19576 } else {
19577 Info.AutoTemplateParameterDepth = TemplateParameterDepth;
19578 Info.NumExplicitTemplateParams = 0;
19579 }
19580}
19581
19583 auto &FSI = InventedParameterInfos.back();
19584 if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
19585 if (FSI.NumExplicitTemplateParams != 0) {
19586 TemplateParameterList *ExplicitParams =
19590 Context, ExplicitParams->getTemplateLoc(),
19591 ExplicitParams->getLAngleLoc(), FSI.TemplateParams,
19592 ExplicitParams->getRAngleLoc(),
19593 ExplicitParams->getRequiresClause()));
19594 } else {
19597 Context, SourceLocation(), SourceLocation(), FSI.TemplateParams,
19598 SourceLocation(), /*RequiresClause=*/nullptr));
19599 }
19600 }
19601 InventedParameterInfos.pop_back();
19602}
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3597
NodeId Parent
Definition: ASTDiff.cpp:191
DynTypedNode Node
StringRef P
const Decl * D
IndirectLocalPath & Path
enum clang::sema::@1840::IndirectLocalPathEntry::EntryKind Kind
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:3180
llvm::DenseSet< const void * > Visited
Definition: HTMLLogger.cpp:145
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
This file declares semantic analysis for CUDA constructs.
static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD, SourceLocation Loc, bool &Res)
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, unsigned Quals, bool ConstRHS, TrivialABIHandling TAH, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial.
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 bool checkSimpleDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElemsAPS, QualType ElemType, llvm::function_ref< ExprResult(SourceLocation, Expr *, unsigned)> GetInit)
static CXXDestructorDecl * LookupDestructorIfRelevant(Sema &S, CXXRecordDecl *Class)
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 IsPotentiallyTypeAwareOperatorNewOrDelete(Sema &SemaRef, const FunctionDecl *FD, bool *WasMalformed)
static bool RefersToRValueRef(Expr *MemRef)
static bool CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallPtrSet< Decl *, 16 > &Inits, bool &Diagnosed, Sema::CheckConstexprKind Kind)
Check that the given field is initialized within a constexpr constructor.
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 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 bool IsPotentiallyDestroyingOperatorDelete(Sema &SemaRef, const FunctionDecl *FD)
static void extendLeft(SourceRange &R, SourceRange Before)
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 EvaluateAsStringImpl(Sema &SemaRef, Expr *Message, ResultType &Result, ASTContext &Ctx, Sema::StringEvaluationContext EvalContext, bool ErrorOnInvalidMessage)
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 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 QualType BuildStdClassTemplate(Sema &S, ClassTemplateDecl *CTD, QualType TypeParam, SourceLocation Loc)
AllocationOperatorKind
static NamespaceDecl * getNamespaceDecl(NamespaceBaseDecl *D)
getNamespaceDecl - Returns the namespace a decl represents.
static Sema::ImplicitExceptionSpecification ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD, Sema::DefaultedComparisonKind DCK)
static bool isDestroyingDeleteT(QualType Type)
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 bool IsUnusedPrivateField(const FieldDecl *FD)
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 bool HasAttribute(const QualType &T)
static bool CheckOperatorNewDeclaration(Sema &SemaRef, FunctionDecl *FnDecl)
static void checkForMultipleExportedDefaultConstructors(Sema &S, CXXRecordDecl *Class)
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, FunctionDecl *FnDecl, AllocationOperatorKind OperatorKind, CanQualType ExpectedResultType, CanQualType ExpectedSizeOrAddressParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, bool ConstArg, TrivialABIHandling TAH, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
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 bool checkArrayDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const ConstantArrayType *CAT)
static ClassTemplateDecl * LookupStdClassTemplate(Sema &S, SourceLocation Loc, const char *ClassName, bool *WasMalformed)
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 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 CheckBindingsCount(Sema &S, DecompositionDecl *DD, QualType DecompType, ArrayRef< BindingDecl * > Bindings, unsigned MemberCount)
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.
static void MarkFieldDestructorReferenced(Sema &S, SourceLocation Location, FieldDecl *Field)
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 bool isStdClassTemplate(Sema &S, QualType SugaredType, QualType *TypeArg, const char *ClassName, ClassTemplateDecl **CachedDecl, const Decl **MalformedDecl)
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 void MarkBaseDestructorsReferenced(Sema &S, SourceLocation Location, CXXRecordDecl *ClassDecl)
static bool CheckMemberDecompositionFields(Sema &S, SourceLocation Loc, const CXXRecordDecl *OrigRD, QualType DecompType, DeclAccessPair BasePair)
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 checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, CXXSpecialMemberKind CSM, TrivialSubobjectKind Kind, TrivialABIHandling TAH, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
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 QualType getStdTrait(Sema &S, SourceLocation Loc, StringRef Trait, TemplateArgumentListInfo &Args, unsigned DiagID)
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 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:753
SourceLocation Loc
Definition: SemaObjC.cpp:754
bool Indirect
Definition: SemaObjC.cpp:755
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.
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)
a trap message and trap category.
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:1201
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:3056
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
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:744
unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built.
Definition: ASTContext.h:3547
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2851
unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:3561
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2867
CanQualType LongDoubleTy
Definition: ASTContext.h:1234
CanQualType Char16Ty
Definition: ASTContext.h:1229
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...
bool hasSeenTypeAwareOperatorNewOrDelete() const
Definition: ASTContext.h:3441
CanQualType VoidPtrTy
Definition: ASTContext.h:1249
void Deallocate(void *Ptr) const
Definition: ASTContext.h:820
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:1250
CanQualType WideCharTy
Definition: ASTContext.h:1226
IdentifierTable & Idents
Definition: ASTContext.h:740
const LangOptions & getLangOpts() const
Definition: ASTContext.h:894
QualType getConstType(QualType T) const
Return the uniqued reference to the type for a const qualified type.
Definition: ASTContext.h:1461
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current context.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier NNS, const IdentifierInfo *Name) const
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:2565
QualType AutoDeductTy
Definition: ASTContext.h:1285
CanQualType BoolTy
Definition: ASTContext.h:1223
unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built.
Definition: ASTContext.h:3526
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:3155
CanQualType CharTy
Definition: ASTContext.h:1224
unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:3540
unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:3533
CanQualType IntTy
Definition: ASTContext.h:1231
unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:3557
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:2442
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:793
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2898
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
QualType getTypeDeclType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypeDecl *Decl) const
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2625
CanQualType BuiltinFnTy
Definition: ASTContext.h:1252
unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
Definition: ASTContext.h:3522
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:3554
CanQualType VoidTy
Definition: ASTContext.h:1222
QualType getPackExpansionType(QualType Pattern, UnsignedOrNone NumExpansions, bool ExpectPackInType=true) const
Form a pack expansion type with the given pattern.
unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:3536
QualType getTypedefType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypedefNameDecl *Decl, QualType UnderlyingType=QualType(), std::optional< bool > TypeMatchesDeclOrNone=std::nullopt) const
Return the unique reference to the type for the specified typedef-name decl.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1233
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:1750
QualType getTagType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TagDecl *TD, bool OwnsTag) 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:3310
CanQualType Char32Ty
Definition: ASTContext.h:1230
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getUnresolvedUsingType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UnresolvedUsingTypenameDecl *D) const
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:859
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
Definition: ASTContext.h:3529
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:1339
CanQualType getCanonicalTagType(const TagDecl *TD) const
unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
Definition: ASTContext.h:3543
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
CanQualType Char8Ty
Definition: ASTContext.h:1228
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
Definition: ASTContext.h:3550
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:168
PtrTy get() const
Definition: Ownership.h:171
bool isInvalid() const
Definition: Ownership.h:167
bool isUsable() const
Definition: Ownership.h:169
Wrapper for source info for arrays.
Definition: TypeLoc.h:1757
TypeLoc getElementLoc() const
Definition: TypeLoc.h:1787
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: TypeBase.h:3738
QualType getElementType() const
Definition: TypeBase.h:3750
Attr - This represents one attribute.
Definition: Attr.h:44
attr::Kind getKind() const
Definition: Attr.h:90
bool isInherited() const
Definition: Attr.h:99
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
Definition: Attr.h:97
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: TypeBase.h:7180
Represents a C++ declaration that introduces decls from somewhere else.
Definition: DeclCXX.h:3490
unsigned shadow_size() const
Return the number of shadowed declarations associated with this using declaration.
Definition: DeclCXX.h:3568
void addShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:3387
shadow_iterator shadow_begin() const
Definition: DeclCXX.h:3560
void removeShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:3396
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4389
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3974
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:4938
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
Definition: Expr.cpp:2137
A binding in a decomposition declaration.
Definition: DeclCXX.h:4179
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T)
Definition: DeclCXX.cpp:3578
void setBinding(QualType DeclaredType, Expr *Binding)
Set the binding for this BindingDecl, along with its declared type (which should be a possibly-cv-qua...
Definition: DeclCXX.h:4217
void setDecomposedDecl(ValueDecl *Decomposed)
Set the decomposed variable for this BindingDecl.
Definition: DeclCXX.h:4223
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:6560
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1506
This class is used for builtin types like 'int'.
Definition: TypeBase.h:3182
Kind getKind() const
Definition: TypeBase.h:3230
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:723
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1549
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:1180
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1612
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2604
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2847
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:3013
ExplicitSpecifier getExplicitSpecifier()
Definition: DeclCXX.h:2676
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2701
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
Definition: DeclCXX.cpp:2990
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:3008
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2999
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2842
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(), const AssociatedConstraint &TrailingRequiresClause={})
Definition: DeclCXX.cpp:2968
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2937
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2977
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2369
bool isWritten() const
Determine whether this initializer is explicitly written in the source code.
Definition: DeclCXX.h:2541
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
Definition: DeclCXX.cpp:2916
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:2903
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2515
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1378
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2869
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, const AssociatedConstraint &TrailingRequiresClause={})
Definition: DeclCXX.cpp:3098
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:1753
Represents a call to a member function that may be written either with member call syntax (e....
Definition: ExprCXX.h:179
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Definition: ExprCXX.cpp:741
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2129
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:2703
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:2710
bool isVirtual() const
Definition: DeclCXX.h:2184
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, const AssociatedConstraint &TrailingRequiresClause={})
Definition: DeclCXX.cpp:2488
unsigned getNumExplicitParams() const
Definition: DeclCXX.h:2283
bool isVolatile() const
Definition: DeclCXX.h:2182
CXXMethodDecl * getMostRecentDecl()
Definition: DeclCXX.h:2232
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2778
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:2772
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
Definition: DeclCXX.cpp:2820
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Definition: DeclCXX.h:2305
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:2762
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2255
bool isInstance() const
Definition: DeclCXX.h:2156
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:2735
QualType getFunctionObjectParameterType() const
Definition: DeclCXX.h:2279
bool isStatic() const
Definition: DeclCXX.cpp:2401
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2225
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:768
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:84
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:1270
friend_range friends() const
Definition: DeclFriend.h:258
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class....
Definition: DeclCXX.h:1341
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
Definition: DeclCXX.cpp:607
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1240
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1673
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1366
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
Definition: DeclCXX.h:1001
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
Definition: DeclCXX.h:820
bool hasInheritedAssignment() const
Determine whether this class has a using-declaration that names a base class assignment operator.
Definition: DeclCXX.h:1420
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
Definition: DeclCXX.h:1391
bool hasTrivialDestructorForCall() const
Definition: DeclCXX.h:1370
bool defaultedMoveConstructorIsDeleted() const
true if a defaulted move constructor for this class would be deleted.
Definition: DeclCXX.h:706
bool isLiteral() const
Determine whether this class is a literal type.
Definition: DeclCXX.cpp:1500
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
Definition: DeclCXX.h:961
bool defaultedDestructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1356
base_class_range bases()
Definition: DeclCXX.h:608
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
Definition: DeclCXX.cpp:600
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1018
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12)
Definition: DeclCXX.h:1301
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
Definition: DeclCXX.h:766
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
Definition: DeclCXX.h:892
bool hasUserDeclaredCopyAssignment() const
Determine whether this class has a user-declared copy assignment operator.
Definition: DeclCXX.h:910
method_range methods() const
Definition: DeclCXX.h:650
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:548
bool needsOverloadResolutionForCopyAssignment() const
Determine whether we need to eagerly declare a defaulted copy assignment operator for this class.
Definition: DeclCXX.h:931
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition: DeclCXX.h:1721
bool defaultedDefaultConstructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1263
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class....
Definition: DeclCXX.h:1278
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
Definition: DeclCXX.h:973
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
Definition: DeclCXX.cpp:595
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
Definition: DeclCXX.h:1214
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:602
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
Definition: DeclCXX.h:697
bool hasTrivialCopyConstructorForCall() const
Definition: DeclCXX.h:1282
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:726
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:2050
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11,...
Definition: DeclCXX.h:1328
base_class_range vbases()
Definition: DeclCXX.h:625
base_class_iterator vbases_begin()
Definition: DeclCXX.h:632
ctor_range ctors() const
Definition: DeclCXX.h:670
void setImplicitMoveConstructorIsDeleted()
Set that we attempted to declare an implicit move constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:867
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1221
bool hasVariantMembers() const
Determine whether this class has any variant members.
Definition: DeclCXX.h:1236
void setImplicitCopyConstructorIsDeleted()
Set that we attempted to declare an implicit copy constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:858
bool isDynamicClass() const
Definition: DeclCXX.h:574
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1148
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition: DeclCXX.h:799
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Definition: DeclCXX.h:1402
bool hasDirectFields() const
Determine whether this class has direct non-static data members.
Definition: DeclCXX.h:1200
bool hasUserDeclaredCopyConstructor() const
Determine whether this class has a user-declared copy constructor.
Definition: DeclCXX.h:793
bool hasDefinition() const
Definition: DeclCXX.h:561
void setImplicitCopyAssignmentIsDeleted()
Set that we attempted to declare an implicit copy assignment operator, but overload resolution failed...
Definition: DeclCXX.h:916
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
Definition: DeclCXX.h:1007
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:2042
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:902
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: DeclCXX.cpp:2146
bool needsOverloadResolutionForMoveAssignment() const
Determine whether we need to eagerly declare a move assignment operator for this class.
Definition: DeclCXX.h:994
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:2121
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
Definition: DeclCXX.h:1013
bool hasInheritedConstructor() const
Determine whether this class has a using-declaration that names a user-declared base class constructo...
Definition: DeclCXX.h:1414
CXXMethodDecl * getLambdaStaticInvoker() const
Retrieve the lambda static invoker, the address of which is returned by the conversion operator,...
Definition: DeclCXX.cpp:1748
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class.
Definition: DeclCXX.h:805
CXXRecordDecl * getDefinitionOrSelf() const
Definition: DeclCXX.h:555
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
Definition: DeclCXX.h:846
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
Definition: DeclCXX.h:983
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared.
Definition: DeclCXX.h:925
bool hasTrivialMoveConstructorForCall() const
Definition: DeclCXX.h:1306
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1736
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:522
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:623
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:946
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:73
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:180
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:185
void MakeTrivial(ASTContext &Context, NestedNameSpecifier Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:97
SourceRange getRange() const
Definition: DeclSpec.h:79
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:83
bool isSet() const
Deprecated.
Definition: DeclSpec.h:198
NestedNameSpecifier getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:94
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
Definition: DeclSpec.cpp:123
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:183
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:178
Represents the this expression in C++.
Definition: ExprCXX.h:1155
SourceLocation getBeginLoc() const
Definition: ExprCXX.h:1175
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:2879
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
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.
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: TypeBase.h:3293
QualType getElementType() const
Definition: TypeBase.h:3303
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1720
body_range body()
Definition: Stmt.h:1783
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:4327
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:196
Represents the canonical version of C arrays with a specified constant size.
Definition: TypeBase.h:3776
llvm::APInt getSize() const
Return the constant array size as an APInt.
Definition: TypeBase.h:3832
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Definition: ASTConcept.h:37
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3671
const CXXRecordDecl * getParent() const
Returns the parent of this using shadow declaration, which is the class in which this is declared.
Definition: DeclCXX.h:3735
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Definition: DeclCXX.cpp:3369
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:1382
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2393
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1449
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:2109
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition: DeclBase.h:2238
bool isFileContext() const
Definition: DeclBase.h:2180
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:2077
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1358
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
Definition: DeclBase.cpp:2059
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1879
bool isTranslationUnit() const
Definition: DeclBase.h:2185
bool isRecord() const
Definition: DeclBase.h:2189
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:2022
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1712
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1793
decl_iterator decls_end() const
Definition: DeclBase.h:2375
bool isStdNamespace() const
Definition: DeclBase.cpp:1342
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2373
bool isFunctionOrMethod() const
Definition: DeclBase.h:2161
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1413
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context semantically encloses the declaration context DC.
Definition: DeclBase.cpp:1428
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1767
Decl::Kind getDeclKind() const
Definition: DeclBase.h:2102
DeclContext * getNonTransparentContext()
Definition: DeclBase.cpp:1450
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1649
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1272
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:484
ValueDecl * getDecl()
Definition: Expr.h:1340
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
Definition: Expr.h:1470
SourceLocation getBeginLoc() const
Definition: Expr.h:1351
Captures information about "declaration specifiers".
Definition: DeclSpec.h:217
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:661
Expr * getPackIndexingExpr() const
Definition: DeclSpec.h:530
TST getTypeSpecType() const
Definition: DeclSpec.h:507
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:480
SCS getStorageClassSpec() const
Definition: DeclSpec.h:471
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:545
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:544
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:586
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:624
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:797
ParsedType getRepAsType() const
Definition: DeclSpec.h:517
bool isFriendSpecifiedFirst() const
Definition: DeclSpec.h:795
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:593
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:587
SourceRange getExplicitSpecRange() const
Definition: DeclSpec.h:625
Expr * getRepAsExpr() const
Definition: DeclSpec.h:525
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:588
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:532
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:590
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:806
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:552
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:427
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:591
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:589
FriendSpecified isFriendSpecified() const
Definition: DeclSpec.h:791
bool hasExplicitSpecifier() const
Definition: DeclSpec.h:621
bool hasConstexprSpecifier() const
Definition: DeclSpec.h:807
static const TST TST_auto
Definition: DeclSpec.h:288
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1611
decl_range decls()
Definition: Stmt.h:1659
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.h:1637
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:1061
bool isInStdNamespace() const
Definition: DeclBase.cpp:427
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:435
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
Definition: DeclBase.h:1226
T * getAttr() const
Definition: DeclBase.h:573
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:524
void addAttr(Attr *A)
Definition: DeclBase.cpp:1022
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:593
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:99
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:244
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:156
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
void clearIdentifierNamespace()
Clears the namespace of this declaration.
Definition: DeclBase.h:1214
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:568
@ FOK_Undeclared
A friend of a previously-undeclared entity.
Definition: DeclBase.h:1219
@ FOK_None
Not a friend object.
Definition: DeclBase.h:1217
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:251
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:2793
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
Definition: DeclBase.cpp:1239
bool isInvalidDecl() const
Definition: DeclBase.h:588
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:889
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1169
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:502
SourceLocation getLocation() const
Definition: DeclBase.h:439
@ IDNS_Ordinary
Ordinary names.
Definition: DeclBase.h:144
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
Definition: DeclBase.cpp:234
void setLocalOwningModule(Module *M)
Definition: DeclBase.h:829
void setImplicit(bool I=true)
Definition: DeclBase.h:594
void setReferenced(bool R=true)
Definition: DeclBase.h:623
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition: DeclBase.cpp:553
DeclContext * getDeclContext()
Definition: DeclBase.h:448
AccessSpecifier getAccess() const
Definition: DeclBase.h:507
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:431
void dropAttr()
Definition: DeclBase.h:556
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:918
bool hasAttr() const
Definition: DeclBase.h:577
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:978
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
Kind getKind() const
Definition: DeclBase.h:442
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:881
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:427
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...
bool isAnyOperatorNewOrDelete() const
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:779
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1988
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:830
const AssociatedConstraint & getTrailingRequiresClause() const
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Definition: Decl.h:854
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:861
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:813
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:808
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1874
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2310
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:2057
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:2036
ArrayRef< TemplateParameterList * > getTemplateParameterLists() const
The template parameter lists that preceded the declarator.
Definition: DeclSpec.h:2623
void setInventedTemplateParameterList(TemplateParameterList *Invented)
Sets the template parameter list generated from the explicit template parameters along with any inven...
Definition: DeclSpec.h:2630
bool isInvalidType() const
Definition: DeclSpec.h:2688
A decomposition declaration.
Definition: DeclCXX.h:4243
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:4281
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
Definition: DeclSpec.h:1762
SourceRange getSourceRange() const
Definition: DeclSpec.h:1810
SourceLocation getLSquareLoc() const
Definition: DeclSpec.h:1808
Represents a C++17 deduced template specialization type.
Definition: TypeBase.h:7228
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2581
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2561
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2570
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...
Definition: Diagnostic.h:1548
bool isLastDiagnosticIgnored() const
Determine whether the previous diagnostic was ignored.
Definition: Diagnostic.h:800
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:950
Recursive AST visitor that supports extension via dynamic dispatch.
virtual bool TraverseConstructorInitializer(MaybeConst< CXXCtorInitializer > *Init)
Recursively visit a constructor initializer.
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:5758
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:3420
Represents an enum.
Definition: Decl.h:4004
enumerator_range enumerators() const
Definition: Decl.h:4141
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Definition: TypeBase.h:6522
EvaluatedExprVisitor - This class visits 'Expr *'s.
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1924
const Expr * getExpr() const
Definition: DeclCXX.h:1933
void setExpr(Expr *E)
Definition: DeclCXX.h:1958
void setKind(ExplicitSpecKind Kind)
Definition: DeclCXX.h:1957
This represents one expression.
Definition: Expr.h:112
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:177
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition: Expr.h:194
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:3073
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3061
bool containsErrors() const
Whether this expression contains subexpressions which had errors.
Definition: Expr.h:246
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3069
bool isPRValue() const
Definition: Expr.h:285
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
Definition: Expr.h:284
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:3207
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:273
QualType getType() const
Definition: Expr.h:144
Represents difference between two FPOptions values.
Definition: LangOptions.h:919
Represents a member of a struct/union/class.
Definition: Decl.h:3157
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
Definition: Decl.cpp:4666
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:3337
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
Definition: Decl.cpp:4656
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:3331
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
Definition: Decl.cpp:4676
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.h:3242
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Definition: Decl.h:3393
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:3404
bool isUnnamedBitField() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:3263
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:78
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:115
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:139
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:128
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:102
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:186
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:3132
Represents a function declaration or definition.
Definition: Decl.h:1999
static constexpr unsigned RequiredTypeAwareDeleteParameterCount
Count of mandatory parameters for type aware operator delete.
Definition: Decl.h:2641
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2794
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:3271
ExceptionSpecificationType getExceptionSpecType() const
Gets the ExceptionSpecificationType as declared.
Definition: Decl.h:2866
bool isTrivialForCall() const
Definition: Decl.h:2379
ConstexprSpecKind getConstexprKind() const
Definition: Decl.h:2475
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3788
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:4134
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:2313
bool isImmediateFunction() const
Definition: Decl.cpp:3328
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
Definition: Decl.cpp:3152
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
Definition: Decl.cpp:3965
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:3539
bool hasCXXExplicitFunctionObjectParameter() const
Definition: Decl.cpp:3806
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2918
SourceLocation getDefaultLoc() const
Definition: Decl.h:2397
QualType getReturnType() const
Definition: Decl.h:2842
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2771
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
Definition: Decl.h:2388
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2376
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:4254
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:2779
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3688
FunctionTypeLoc getFunctionTypeLoc() const
Find the source location information for how the type of this function was written.
Definition: Decl.cpp:3942
param_iterator param_begin()
Definition: Decl.h:2783
const ParmVarDecl * getNonObjectParameter(unsigned I) const
Definition: Decl.h:2820
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:3125
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2325
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2539
void setBodyContainsImmediateEscalatingExpressions(bool Set)
Definition: Decl.h:2485
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:4270
FunctionEffectsRef getFunctionEffects() const
Definition: Decl.h:3131
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition: Decl.cpp:4198
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2885
bool isStatic() const
Definition: Decl.h:2926
void setTrivial(bool IT)
Definition: Decl.h:2377
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:4085
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2469
static constexpr unsigned RequiredTypeAwareNewParameterCount
Count of mandatory parameters for type aware operator new.
Definition: Decl.h:2637
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2352
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:3559
bool isImmediateEscalating() const
Definition: Decl.cpp:3303
void setIsDestroyingOperatorDelete(bool IsDestroyingDelete)
Definition: Decl.cpp:3543
bool isTypeAwareOperatorNewOrDelete() const
Determine whether this is a type aware operator new or delete.
Definition: Decl.cpp:3547
void setIsTypeAwareOperatorNewOrDelete(bool IsTypeAwareOperator=true)
Definition: Decl.cpp:3551
bool isDefaulted() const
Whether this function is defaulted.
Definition: Decl.h:2384
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4490
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2930
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Definition: Decl.cpp:4071
void setConstexprKind(ConstexprSpecKind CSK)
Definition: Decl.h:2472
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:4358
void setDefaulted(bool D=true)
Definition: Decl.h:2385
bool isConsteval() const
Definition: Decl.h:2481
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
Definition: Decl.h:2409
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:2859
void setBody(Stmt *B)
Definition: Decl.cpp:3283
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2343
bool hasOneParamOrDefaultArgs() const
Determine whether this function has a single parameter, or multiple parameters where all but the firs...
Definition: Decl.cpp:3820
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3767
size_t param_size() const
Definition: Decl.h:2787
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:2210
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:3191
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:3238
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
Definition: Decl.cpp:3186
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
Definition: Decl.h:2802
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Definition: Decl.h:2682
A mutable set of FunctionEffects and possibly conditions attached to them.
Definition: TypeBase.h:5218
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
Definition: Type.cpp:5637
An immutable set of FunctionEffects and possibly conditions attached to them.
Definition: TypeBase.h:5082
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, ValueDecl *ParamPack, SourceLocation NameLoc, ArrayRef< ValueDecl * > Params)
Definition: ExprCXX.cpp:1816
Represents a prototype with parameter type info, e.g.
Definition: TypeBase.h:5282
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: TypeBase.h:5786
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: TypeBase.h:5589
unsigned getNumParams() const
Definition: TypeBase.h:5560
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: TypeBase.h:5702
QualType getParamType(unsigned i) const
Definition: TypeBase.h:5562
ExtProtoInfo getExtProtoInfo() const
Definition: TypeBase.h:5571
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition: TypeBase.h:5647
ArrayRef< QualType > getParamTypes() const
Definition: TypeBase.h:5567
ArrayRef< QualType > exceptions() const
Definition: TypeBase.h:5736
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
Definition: TypeBase.h:5751
Declaration of a template function.
Definition: DeclTemplate.h:952
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:998
Wrapper for source info for functions.
Definition: TypeLoc.h:1624
unsigned getNumParams() const
Definition: TypeLoc.h:1696
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1702
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1703
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1705
ExtInfo withCallingConv(CallingConv cc) const
Definition: TypeBase.h:4701
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: TypeBase.h:4478
CallingConv getCallConv() const
Definition: TypeBase.h:4833
QualType getReturnType() const
Definition: TypeBase.h:4818
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:2259
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition: Expr.h:1733
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3789
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Definition: Expr.cpp:2068
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5993
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3464
void setInherited(bool I)
Definition: Attr.h:156
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2575
ConstructorUsingShadowDecl * getShadowDecl() const
Definition: DeclCXX.h:2587
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:531
Describes an C or C++ initializer list.
Definition: Expr.h:5235
unsigned getNumInits() const
Definition: Expr.h:5265
const Expr * getInit(unsigned Init) const
Definition: Expr.h:5289
child_range children()
Definition: Expr.h:5434
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:7739
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:3651
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.
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:971
An lvalue reference type, per C++11 [dcl.ref].
Definition: TypeBase.h:3633
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:1970
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
Definition: ExprCXX.cpp:1358
capture_range captures() const
Retrieve this lambda's captures.
Definition: ExprCXX.cpp:1371
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:619
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:1020
Represents a linkage specification.
Definition: DeclCXX.h:3009
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LinkageSpecLanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:3184
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:3051
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:677
void erase()
Erase the last element returned from this iterator.
Definition: Lookup.h:723
bool hasNext() const
Definition: Lookup.h:708
NamedDecl * next()
Definition: Lookup.h:712
Represents the results of name lookup.
Definition: Lookup.h:147
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:607
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:488
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:666
Filter makeFilter()
Create a filter for this result set.
Definition: Lookup.h:751
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:569
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:576
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:636
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:4338
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:3653
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3300
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:3383
Expr * getBase() const
Definition: Expr.h:3377
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:3495
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1524
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: TypeBase.h:3669
Describes a module or submodule.
Definition: Module.h:144
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:732
bool isExplicitGlobalModule() const
Definition: Module.h:242
This represents a decl that may have a name.
Definition: Decl.h:273
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:486
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:294
bool isPlaceholderVar(const LangOptions &LangOpts) const
Definition: Decl.cpp:1095
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:339
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
Definition: DeclBase.h:706
Represents a C++ namespace alias.
Definition: DeclCXX.h:3195
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamespaceBaseDecl *Namespace)
Definition: DeclCXX.cpp:3285
Represents C++ namespaces and their aliases.
Definition: Decl.h:572
NamespaceDecl * getNamespace()
Definition: DeclCXX.cpp:3222
Represent a C++ namespace.
Definition: Decl.h:591
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:647
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
Definition: DeclCXX.cpp:3245
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace that inhabits this namespace, if any.
Definition: Decl.h:674
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:693
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>::".
NestedNameSpecifier getCanonical() const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
@ Global
The global specifier '::'. There is no stored value.
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:81
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1180
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
Definition: Overload.h:1153
@ CSK_Normal
Normal lookup.
Definition: Overload.h:1157
@ CSK_Operator
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax.
Definition: Overload.h:1164
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:1369
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:256
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
Definition: Expr.cpp:4810
Represents a parameter to a function.
Definition: Decl.h:1789
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:3014
SourceLocation getExplicitObjectParamThisLoc() const
Definition: Decl.h:1885
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1930
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1918
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:3019
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:3039
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1822
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1922
bool hasInheritedDefaultArg() const
Definition: Decl.h:1934
bool isExplicitObjectParameter() const
Definition: Decl.h:1877
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:2946
Expr * getDefaultArg()
Definition: Decl.cpp:3002
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:3044
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:3050
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1938
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2969
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:119
IdentifierInfo * getPropertyDataSetter() const
Definition: ParsedAttr.h:470
IdentifierInfo * getPropertyDataGetter() const
Definition: ParsedAttr.h:464
static const ParsedAttributesView & none()
Definition: ParsedAttr.h:817
bool hasAttribute(ParsedAttr::Kind K) const
Definition: ParsedAttr.h:897
Pointer-authentication qualifiers.
Definition: TypeBase.h:152
bool isAddressDiscriminated() const
Definition: TypeBase.h:265
Wrapper for source info for pointers.
Definition: TypeLoc.h:1493
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: TypeBase.h:3346
QualType getPointeeType() const
Definition: TypeBase.h:3356
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
bool NeedsStdLibCxxWorkaroundBefore(std::uint64_t FixedVersion)
IdentifierTable & getIdentifierTable()
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6692
ArrayRef< Expr * > semantics()
Definition: Expr.h:6764
A (possibly-)qualified type.
Definition: TypeBase.h:937
bool hasAddressDiscriminatedPointerAuth() const
Definition: TypeBase.h:1457
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: TypeBase.h:8427
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: TypeBase.h:8432
PointerAuthQualifier getPointerAuth() const
Definition: TypeBase.h:1453
QualType withConst() const
Definition: TypeBase.h:1159
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: TypeBase.h:1225
void addConst()
Add the const type qualifier to this QualType.
Definition: TypeBase.h:1156
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: TypeBase.h:1004
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: TypeBase.h:8343
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: TypeBase.h:8383
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: TypeBase.h:1438
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: TypeBase.h:8528
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: TypeBase.h:8437
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
Definition: Type.cpp:2944
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: TypeBase.h:1089
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: TypeBase.h:8416
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: TypeBase.h:8389
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: TypeBase.h:1332
bool hasNonTrivialObjCLifetime() const
Definition: TypeBase.h:1442
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2699
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: TypeBase.h:8508
Represents a template name as written in source code.
Definition: TemplateName.h:504
The collection of all-type qualifiers we support.
Definition: TypeBase.h:331
void removeCVRQualifiers(unsigned mask)
Definition: TypeBase.h:495
void addAddressSpace(LangAS space)
Definition: TypeBase.h:597
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition: TypeBase.h:361
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition: TypeBase.h:364
void removeConst()
Definition: TypeBase.h:459
void removeAddressSpace()
Definition: TypeBase.h:596
void removeVolatile()
Definition: TypeBase.h:469
std::string getAsString() const
LangAS getAddressSpace() const
Definition: TypeBase.h:571
void setObjCLifetime(ObjCLifetime type)
Definition: TypeBase.h:548
An rvalue reference type, per C++11 [dcl.ref].
Definition: TypeBase.h:3651
Represents a struct/union/class.
Definition: Decl.h:4309
bool hasFlexibleArrayMember() const
Definition: Decl.h:4342
bool hasObjectMember() const
Definition: Decl.h:4369
field_iterator field_end() const
Definition: Decl.h:4515
field_range fields() const
Definition: Decl.h:4512
RecordDecl * getDefinitionOrSelf() const
Definition: Decl.h:4497
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Definition: Decl.h:4361
bool field_empty() const
Definition: Decl.h:4520
field_iterator field_begin() const
Definition: Decl.cpp:5154
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: TypeBase.h:6502
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:213
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:201
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:223
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:5292
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:293
Base for LValueReferenceType and RValueReferenceType.
Definition: TypeBase.h:3589
QualType getPointeeType() const
Definition: TypeBase.h:3607
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Definition: Stmt.h:3160
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:409
void AddDecl(Decl *D)
Definition: Scope.h:362
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:287
@ 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:111
SemaDiagnosticBuilder DiagCompat(SourceLocation Loc, unsigned CompatDiagId, bool DeferHint=false)
Emit a compatibility diagnostic.
Definition: SemaBase.cpp:91
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: SemaBase.cpp:61
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaBase.cpp:33
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:371
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:1283
bool isInvalid() const
Definition: Sema.h:7768
A RAII object to temporarily push a declaration context.
Definition: Sema.h:3468
For a defaulted function, the kind of defaulted function that it is.
Definition: Sema.h:6313
DefaultedComparisonKind asComparison() const
Definition: Sema.h:6345
CXXSpecialMemberKind asSpecialMember() const
Definition: Sema.h:6342
Helper class that collects exception specifications for implicitly-declared special member functions.
Definition: Sema.h:5411
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:9239
CXXMethodDecl * getMethod() const
Definition: Sema.h:9251
RAII object to handle the state changes required to synthesize a function body.
Definition: Sema.h:13384
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:7668
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:850
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:11188
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
Definition: SemaDecl.cpp:6857
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
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:12936
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:9951
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:6502
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:1617
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:15759
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:6264
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:9281
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
Definition: Sema.h:9308
@ LookupLocalFriendName
Look up a friend of a local class.
Definition: Sema.h:9316
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
Definition: Sema.h:9304
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:9289
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:405
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
Definition: SemaDecl.cpp:6790
Decl * ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceRange TyLoc, const IdentifierInfo &II, ParsedType Ty, CXXScopeSpec *SS=nullptr)
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)
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, ImplicitDeallocationParameters, bool Diagnose=true)
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:6251
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)
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr, bool ForFoldExpression=false)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
Definition: SemaExpr.cpp:15069
void PrintContextStack()
Definition: Sema.h:13520
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings={})
Definition: SemaDecl.cpp:7611
SemaOpenMP & OpenMP()
Definition: Sema.h:1498
void CheckDelegatingCtorCycles()
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
Definition: Sema.h:6239
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:6236
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:1234
QualType tryBuildStdTypeIdentity(QualType Type, SourceLocation Loc)
Looks for the std::type_identity template and instantiates it with Type, or returns a null type if ty...
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:6475
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:6456
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:1193
SemaCUDA & CUDA()
Definition: Sema.h:1438
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:17664
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 GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicCallType::DoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
Definition: SemaExpr.cpp:6030
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:1653
@ AR_accessible
Definition: Sema.h:1651
@ AR_inaccessible
Definition: Sema.h:1652
@ AR_delayed
Definition: Sema.h:1654
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:2442
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:2311
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:6393
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:4967
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...
bool IsCXXTriviallyRelocatableType(QualType T)
Determines if a type is trivially relocatable according to the C++26 rules.
@ 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:48
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:18875
FPOptionsOverride CurFPFeatureOverrides()
Definition: Sema.h:2042
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...
QualType CheckTemplateIdType(ElaboratedTypeKeyword Keyword, TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
ASTContext & Context
Definition: Sema.h:1276
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:5943
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:915
void DiagnoseTypeTraitDetails(const Expr *E)
If E represents a built-in type trait, or a known standard type trait, try to print more information ...
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
bool isStdTypeIdentity(QualType Ty, QualType *TypeArgument, const Decl **MalformedDecl=nullptr)
Tests whether Ty is an instance of std::type_identity and, if it is and TypeArgument is not NULL,...
SemaObjC & ObjC()
Definition: Sema.h:1483
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, TrivialABIHandling TAH=TrivialABIHandling::IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
Definition: SemaDecl.cpp:5077
void CheckDelayedMemberExceptionSpecs()
void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param)
This is used to implement the constant expression evaluation part of the attribute enable_if extensio...
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1555
ASTContext & getASTContext() const
Definition: Sema.h:918
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>.
Definition: Sema.h:6482
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:20253
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:6566
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:18155
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:756
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:6034
@ 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.
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 RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
Definition: SemaType.cpp:9606
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMemberKind > SpecialMemberDecl
Definition: Sema.h:6497
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:1184
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:2298
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:12073
EnumDecl * getStdAlignValT() const
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
Definition: Sema.cpp:1666
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
Definition: Sema.h:8307
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
Definition: SemaType.cpp:1579
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:2330
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:913
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)
Definition: SemaExpr.cpp:20761
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:83
@ UPPC_RequiresClause
Definition: Sema.h:14289
@ UPPC_UsingDeclaration
A using declaration.
Definition: Sema.h:14244
@ UPPC_ExceptionType
The type of an exception.
Definition: Sema.h:14262
@ UPPC_Initializer
An initializer.
Definition: Sema.h:14253
@ UPPC_BaseType
The base type of a class type.
Definition: Sema.h:14223
@ UPPC_FriendDeclaration
A friend declaration.
Definition: Sema.h:14247
@ UPPC_DefaultArgument
A default argument.
Definition: Sema.h:14256
@ UPPC_DeclarationType
The type of an arbitrary declaration.
Definition: Sema.h:14226
@ UPPC_DataMemberType
The type of a data member.
Definition: Sema.h:14229
@ UPPC_StaticAssertExpression
The expression in a static assertion.
Definition: Sema.h:14235
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:911
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...
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< AssociatedConstraint > AssociatedConstraints, 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:14709
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:5813
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:1446
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:1275
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:6572
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:8417
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.
const LangOptions & LangOpts
Definition: Sema.h:1274
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:17820
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
Definition: SemaInit.cpp:7699
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:6460
SemaHLSL & HLSL()
Definition: Sema.h:1448
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:12098
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:5819
void CheckCXXDefaultArguments(FunctionDecl *FD)
Helpers for dealing with blocks and functions.
ComparisonCategoryUsage
Definition: Sema.h:5193
@ 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:6453
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:20409
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:3775
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:6558
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
Definition: Sema.h:6490
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)
bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L, CXXScopeSpec *SS=nullptr)
Require that the EnumDecl is completed with its enumerators defined or instantiated.
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
void MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl< const CXXRecordDecl * > *DirectVirtualBases=nullptr)
Mark destructors of virtual bases of this class referenced.
void ExitDeclaratorContext(Scope *S)
Definition: SemaDecl.cpp:1433
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.
bool EvaluateAsString(Expr *Message, APValue &Result, ASTContext &Ctx, StringEvaluationContext EvalContext, bool ErrorOnInvalidMessage)
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:1859
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:12948
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:5809
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:633
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:3230
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition: Sema.h:15324
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:9807
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:15821
bool DiagnoseUseOfOverloadedDecl(NamedDecl *D, SourceLocation Loc)
Definition: Sema.h:6927
std::unique_ptr< RecordDeclSetTy > PureVirtualClassDiagSet
PureVirtualClassDiagSet - a set of class declarations which we have emitted a list of pure virtual fu...
Definition: Sema.h:6467
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
Definition: SemaDecl.cpp:15745
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:1411
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:15277
ClassTemplateDecl * StdTypeIdentity
The C++ "std::type_identity" template, which is defined in <type_traits>.
Definition: Sema.h:6486
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Definition: SemaDecl.cpp:5948
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)
bool IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived, CXXRecordDecl *Base, CXXBasePaths &Paths)
Determine whether the type Derived is a C++ class that is derived from the type Base.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
Definition: Sema.h:8122
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 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:20356
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:2253
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:13791
SourceManager & getSourceManager() const
Definition: Sema.h:916
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD, bool Diagnose=true)
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:1398
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:9267
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
Definition: SemaType.cpp:9845
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.
StringEvaluationContext
Definition: Sema.h:5929
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc)
PushNamespaceVisibilityAttr - Note that we've entered a namespace with a visibility attribute.
Definition: SemaAttr.cpp:1480
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 ...
FunctionDecl * BuildTypeAwareUsualDelete(FunctionTemplateDecl *FnDecl, QualType AllocType, SourceLocation)
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:218
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:8440
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)
void DiagnoseUnknownAttribute(const ParsedAttr &AL)
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
Definition: SemaStmt.cpp:3946
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
Definition: Sema.h:15279
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...
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:14616
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:6478
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.
void FinalizeVarWithDestructor(VarDecl *VD, CXXRecordDecl *DeclInit)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=AllowFoldKind::No)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:17422
ASTConsumer & Consumer
Definition: Sema.h:1277
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:4622
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:123
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:5197
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:9813
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
Definition: SemaType.cpp:5693
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:17555
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:9241
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:1239
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
Definition: SemaDecl.cpp:19507
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:1489
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:7555
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:18228
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1366
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AvailabilityMergeKind::Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
Definition: SemaDecl.cpp:3184
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
Definition: Sema.h:1279
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:1278
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:7738
TypeAwareAllocationMode ShouldUseTypeAwareOperatorNewOrDelete() const
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:7434
@ TPC_Other
Definition: Sema.h:11527
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:6894
ExprResult ActOnIntegerConstant(SourceLocation Loc, int64_t Val)
Definition: SemaExpr.cpp:3635
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
Definition: SemaExpr.cpp:5658
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
void PopDeclContext()
Definition: SemaDecl.cpp:1373
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:2893
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:6494
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:1637
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
Definition: SemaExpr.cpp:8995
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:1622
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:13696
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:337
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:6238
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:18401
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,...
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:21528
UnsignedOrNone GetDecompositionElementCount(QualType DecompType, SourceLocation Loc)
Decl * ActOnDeclarator(Scope *S, Declarator &D)
Definition: SemaDecl.cpp:6210
AbstractDiagSelID
Definition: Sema.h:6184
@ AbstractVariableType
Definition: Sema.h:6188
@ AbstractReturnType
Definition: Sema.h:6186
@ AbstractNone
Definition: Sema.h:6185
@ AbstractFieldType
Definition: Sema.h:6189
@ AbstractArrayType
Definition: Sema.h:6192
@ AbstractParamType
Definition: Sema.h:6187
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
Definition: SemaStmt.cpp:950
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:1761
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
Definition: Sema.h:8311
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
CheckConstexprKind
Definition: Sema.h:6373
@ 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:2773
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:436
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:3461
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
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:6197
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:5409
ValueDecl * tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl, const IdentifierInfo *MemberOrBase)
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:653
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer * > Initializers={})
void DiagnoseImmediateEscalatingReason(FunctionDecl *FD)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Definition: Sema.h:8599
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:3551
Stmt - This represents one statement.
Definition: Stmt.h:85
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:358
child_range children()
Definition: Stmt.cpp:295
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:334
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:346
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:1801
bool isUnevaluated() const
Definition: Expr.h:1923
StringRef getString() const
Definition: Expr.h:1869
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3714
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3829
StringRef getKindName() const
Definition: Decl.h:3904
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3809
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:4840
bool isUnion() const
Definition: Decl.h:3919
TagKind getTagKind() const
Definition: Decl.h:3908
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3854
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:810
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:1288
virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const
Definition: TargetInfo.cpp:622
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1360
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
Definition: TargetInfo.h:1326
A convenient class for passing around template argument information.
Definition: TemplateBase.h:634
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:669
ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:661
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:528
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:296
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:396
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:415
Represents a C++ template name within the type system.
Definition: TemplateName.h:222
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:74
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:146
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:182
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:1897
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: TypeBase.h:7290
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 getDepth() const
Definition: TypeBase.h:6931
The top declaration context.
Definition: Decl.h:104
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3685
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:5680
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:3704
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:3510
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
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:171
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:1417
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:154
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:160
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:227
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:2843
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:193
A container of type source information.
Definition: TypeBase.h:8314
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:272
QualType getType() const
Return the type wrapped by this type source info.
Definition: TypeBase.h:8325
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:556
The base class of the type hierarchy.
Definition: TypeBase.h:1833
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:2572
bool isVoidType() const
Definition: TypeBase.h:8936
bool isBooleanType() const
Definition: TypeBase.h:9066
const TemplateSpecializationType * getAsNonAliasTemplateSpecializationType() const
Look through sugar for an instance of TemplateSpecializationType which is not a type alias,...
Definition: Type.cpp:1921
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2998
bool isIncompleteArrayType() const
Definition: TypeBase.h:8687
bool isUndeducedAutoType() const
Definition: TypeBase.h:8766
bool isRValueReferenceType() const
Definition: TypeBase.h:8612
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.h:26
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition: Type.h:41
bool isArrayType() const
Definition: TypeBase.h:8679
bool isPointerType() const
Definition: TypeBase.h:8580
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: TypeBase.h:8980
const T * castAs() const
Member-template castAs<specific type>.
Definition: TypeBase.h:9226
bool isReferenceType() const
Definition: TypeBase.h:8604
bool isEnumeralType() const
Definition: TypeBase.h:8711
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
Definition: Type.cpp:3363
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:752
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Definition: Type.h:65
bool isLValueReferenceType() const
Definition: TypeBase.h:8608
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: TypeBase.h:8905
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: TypeBase.h:2800
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: TypeBase.h:2423
QualType getCanonicalTypeInternal() const
Definition: TypeBase.h:3137
bool containsErrors() const
Whether this type is an error type.
Definition: TypeBase.h:2794
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: TypeBase.h:9109
bool isFunctionProtoType() const
Definition: TypeBase.h:2619
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Definition: TypeBase.h:9079
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: TypeBase.h:2818
bool isObjCObjectType() const
Definition: TypeBase.h:8753
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:5355
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: TypeBase.h:9072
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
Definition: Type.h:53
bool isFunctionType() const
Definition: TypeBase.h:8576
bool isObjCObjectPointerType() const
Definition: TypeBase.h:8749
bool isStructureOrClassType() const
Definition: Type.cpp:706
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:2324
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
Definition: TypeBase.h:2939
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:2257
const T * getAs() const
Member-template getAs<specific type>'.
Definition: TypeBase.h:9159
bool isRecordType() const
Definition: TypeBase.h:8707
bool isUnionType() const
Definition: Type.cpp:718
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3559
QualType getUnderlyingType() const
Definition: Decl.h:3614
Wrapper for source info for typedefs.
Definition: TypeLoc.h:782
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:2246
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:4995
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:998
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:432
A set of unresolved declarations.
Definition: UnresolvedSet.h:62
ArrayRef< DeclAccessPair > pairs() const
Definition: UnresolvedSet.h:89
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:4112
static UnresolvedUsingIfExistsDecl * Create(ASTContext &Ctx, DeclContext *DC, SourceLocation Loc, DeclarationName Name)
Definition: DeclCXX.cpp:3530
Wrapper for source info for unresolved typename using decls.
Definition: TypeLoc.h:787
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:4031
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3509
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3934
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3481
Represents a C++ using-declaration.
Definition: DeclCXX.h:3585
bool hasTypename() const
Return true if the using declaration has 'typename'.
Definition: DeclCXX.h:3634
NestedNameSpecifier getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3622
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3626
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:3418
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Definition: DeclCXX.h:3612
Represents C++ using-directive.
Definition: DeclCXX.h:3090
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:3201
Represents a C++ using-enum-declaration.
Definition: DeclCXX.h:3786
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, TypeSourceInfo *EnumType)
Definition: DeclCXX.cpp:3439
static UsingPackDecl * Create(ASTContext &C, DeclContext *DC, NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > UsingDecls)
Definition: DeclCXX.cpp:3461
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3393
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, DeclarationName Name, BaseUsingDecl *Introducer, NamedDecl *Target)
Definition: DeclCXX.h:3429
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3457
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Definition: DeclCXX.cpp:3358
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:711
void setType(QualType newType)
Definition: Decl.h:723
QualType getType() const
Definition: Decl.h:722
bool isParameterPack() const
Determine whether this value is actually a function parameter pack, init-capture pack,...
Definition: Decl.cpp:5461
Represents a variable declaration or definition.
Definition: Decl.h:925
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2810
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:2151
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1568
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition: Decl.cpp:2260
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2190
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:2836
void setCXXCondDecl()
Definition: Decl.h:1614
bool isInlineSpecified() const
Definition: Decl.h:1553
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2575
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1282
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1225
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:1207
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2851
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1176
const Expr * getInit() const
Definition: Decl.h:1367
@ TLS_Dynamic
TLS with a dynamic initializer.
Definition: Decl.h:951
void setInit(Expr *I)
Definition: Decl.cpp:2477
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1167
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:2528
void setExceptionVariable(bool EV)
Definition: Decl.h:1496
Declaration of a variable template.
Represents a GCC generic vector type.
Definition: TypeBase.h:4191
unsigned getNumElements() const
Definition: TypeBase.h:4206
QualType getElementType() const
Definition: TypeBase.h:4205
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2754
SourceLocation getOverrideLoc() const
Definition: DeclSpec.h:2774
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2786
bool isOverrideSpecified() const
Definition: DeclSpec.h:2773
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2778
bool isFinalSpecified() const
Definition: DeclSpec.h:2776
bool isFinalSpelledSealed() const
Definition: DeclSpec.h:2777
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
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
#define UINT_MAX
Definition: limits.h:64
bool Comp(InterpState &S, CodePtr OpPC)
1) Pops the value from the stack.
Definition: Interp.h:985
bool Inc(InterpState &S, CodePtr OpPC, bool CanOverflow)
1) Pops a pointer from the stack 2) Load the value from the pointer 3) Writes the value increased by ...
Definition: Interp.h:865
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:33
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
@ NonFunction
This is not an overload because the lookup results contain a non-function.
@ Match
This is not an overload because the signature exactly matches an existing declaration.
@ Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
bool isa(CodeGen::Address addr)
Definition: Address.h:330
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
VariadicCallType
Definition: Sema.h:511
LinkageSpecLanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:3001
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ Found
Name lookup found a single declaration that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
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: TypeBase.h:1782
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
Definition: TypeBase.h:1788
@ 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:1541
@ OK_Ordinary
An ordinary object is located at an address in memory.
Definition: Specifiers.h:151
BinaryOperatorKind
@ Redeclaration
Merge availability attributes for a redeclaration, which requires an exact match.
std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl *, const TemplateSpecializationType *, const SubstBuiltinTemplatePackType * >, SourceLocation > UnexpandedParameterPack
Definition: Sema.h:235
@ 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.
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
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
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.
@ Dependent
Parse the block as a dependent block, which may be used in some template instantiations but not other...
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:266
@ 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:62
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:51
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
@ Template
We are parsing a template declaration.
void EscapeStringForDiagnostic(StringRef Str, SmallVectorImpl< char > &OutStr)
EscapeStringForDiagnostic - Append Str to the diagnostic buffer, escaping non-printable characters an...
llvm::Expected< QualType > ExpectedType
Definition: ASTImporter.cpp:78
ReservedLiteralSuffixIdStatus
ActionResult< Expr * > ExprResult
Definition: Ownership.h:249
TagTypeKind
The kind of a tag type.
Definition: TypeBase.h:5906
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:263
ExprResult ExprError()
Definition: Ownership.h:265
@ Keyword
The name has been typo-corrected to a keyword.
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.
AllowFoldKind
Definition: Sema.h:653
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:1103
ComparisonCategoryType
An enumeration representing the different comparison categories types.
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:250
CXXSpecialMemberKind
Kinds of C++ special members.
Definition: Sema.h:424
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:251
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
TypeAwareAllocationMode
Definition: ExprCXX.h:2253
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1288
TrivialABIHandling
Definition: Sema.h:643
@ ConsiderTrivialABI
The triviality of a method affected by "trivial_abi".
@ IgnoreTrivialABI
The triviality of a method unaffected by "trivial_abi".
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.
@ Success
Template argument deduction was successful.
@ 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
TypeAwareAllocationMode typeAwareAllocationModeFromBool(bool IsTypeAwareAllocation)
Definition: ExprCXX.h:2260
@ StaticAssertMessageData
Call to data() in a static assert message.
@ StaticAssertMessageSize
Call to size() in a static assert message.
@ ExplicitBool
Condition in an explicit(bool) specifier.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: TypeBase.h:5881
@ 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 isLambdaMethod(const DeclContext *DC)
Definition: ASTLambda.h:39
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)
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:259
@ 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:1338
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1398
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1347
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
Definition: DeclSpec.h:1401
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
Definition: DeclSpec.h:1499
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1373
bool hasMutableQualifier() const
Determine whether this lambda-declarator contains a 'mutable' qualifier.
Definition: DeclSpec.h:1528
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
Definition: DeclSpec.h:1531
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1437
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1524
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter's default argument cannot be parsed immediately (because it occ...
Definition: DeclSpec.h:1313
One instance of this struct is used for each type in a declarator that is parsed.
Definition: DeclSpec.h:1221
SourceRange getSourceRange() const
Definition: DeclSpec.h:1233
FunctionTypeInfo Fun
Definition: DeclSpec.h:1612
enum clang::DeclaratorChunk::@211 Kind
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:645
Holds information about the various types of exception specification.
Definition: TypeBase.h:5339
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: TypeBase.h:5351
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: TypeBase.h:5341
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: TypeBase.h:5344
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition: TypeBase.h:5347
Extra information about a function prototype.
Definition: TypeBase.h:5367
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: TypeBase.h:5945
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:3264
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:3246
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:1188
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:12953
@ MarkingClassDllexported
We are marking a class as __dllexport.
Definition: Sema.h:13047
@ InitializingStructuredBinding
We are initializing a structured binding.
Definition: Sema.h:13044
@ ExceptionSpecEvaluation
We are computing the exception specification for a defaulted special member function.
Definition: Sema.h:12997
@ DeclaringSpecialMember
We are declaring an implicit special member function.
Definition: Sema.h:13011
@ DeclaringImplicitEqualityComparison
We are declaring an implicit 'operator==' for a defaulted 'operator<=>'.
Definition: Sema.h:13015
Abstract class used to diagnose incomplete types.
Definition: Sema.h:8203
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.