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"
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/CXXInheritance.h"
18#include "clang/AST/CharUnits.h"
19#include "clang/AST/ComparisonCategories.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/DynamicRecursiveASTVisitor.h"
23#include "clang/AST/EvaluatedExprVisitor.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/ExprCXX.h"
26#include "clang/AST/RecordLayout.h"
27#include "clang/AST/StmtVisitor.h"
28#include "clang/AST/TypeLoc.h"
29#include "clang/AST/TypeOrdering.h"
30#include "clang/Basic/AttributeCommonInfo.h"
31#include "clang/Basic/PartialDiagnostic.h"
32#include "clang/Basic/Specifiers.h"
33#include "clang/Basic/TargetInfo.h"
34#include "clang/Lex/LiteralSupport.h"
35#include "clang/Lex/Preprocessor.h"
36#include "clang/Sema/CXXFieldCollector.h"
37#include "clang/Sema/DeclSpec.h"
38#include "clang/Sema/EnterExpressionEvaluationContext.h"
39#include "clang/Sema/Initialization.h"
40#include "clang/Sema/Lookup.h"
41#include "clang/Sema/Ownership.h"
42#include "clang/Sema/ParsedTemplate.h"
43#include "clang/Sema/Scope.h"
44#include "clang/Sema/ScopeInfo.h"
45#include "clang/Sema/SemaCUDA.h"
46#include "clang/Sema/SemaInternal.h"
47#include "clang/Sema/SemaObjC.h"
48#include "clang/Sema/SemaOpenMP.h"
49#include "clang/Sema/Template.h"
50#include "clang/Sema/TemplateDeduction.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(S: 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>(Val: DRE->getDecl());
102
103 if (!isa<VarDecl, BindingDecl>(Val: Decl))
104 return false;
105
106 if (const auto *Param = dyn_cast<ParmVarDecl>(Val: 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(Loc: DRE->getBeginLoc(),
117 DiagID: 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(Loc: DRE->getBeginLoc(),
134 DiagID: 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(Loc: ThisE->getBeginLoc(),
146 DiagID: 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>(Val: E)) {
156 E = OVE->getSourceExpr();
157 assert(E && "pseudo-object binding without source expression?");
158 }
159
160 Invalid |= Visit(S: 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(Capture: &LC))
174 return S.Diag(Loc: LC.getLocation(), DiagID: diag::err_lambda_capture_default_arg);
175 // Init captures are always VarDecl.
176 auto *D = cast<VarDecl>(Val: LC.getCapturedVar());
177 Invalid |= Visit(S: D->getInit());
178 }
179 return Invalid;
180}
181} // namespace
182
183void
184Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc,
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(Loc: CallLoc, FPT: Proto);
193 if (!Proto)
194 return;
195
196 ExceptionSpecificationType EST = Proto->getExceptionSpecType();
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:
207 case EST_Uninstantiated:
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;
219 case EST_NoexceptFalse:
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.
226 case EST_BasicNoexcept:
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;
236 case EST_DependentNoexcept:
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(Ptr: Self->Context.getCanonicalType(T: E)).second)
249 Exceptions.push_back(Elt: E);
250}
251
252void Sema::ImplicitExceptionSpecification::CalledStmt(Stmt *S) {
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(E: S))
278 ComputedEST = EST_None;
279}
280
281ExprResult Sema::ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
282 SourceLocation EqualLoc) {
283 if (RequireCompleteType(Loc: Param->getLocation(), T: Param->getType(),
284 DiagID: 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).
293 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
294 Parm: Param);
295 InitializationKind Kind = InitializationKind::CreateCopy(InitLoc: Param->getLocation(),
296 EqualLoc);
297 InitializationSequence InitSeq(*this, Entity, Kind, Arg);
298 ExprResult Result = InitSeq.Perform(S&: *this, Entity, Kind, Args: Arg);
299 if (Result.isInvalid())
300 return true;
301 Arg = Result.getAs<Expr>();
302
303 CheckCompletedExpr(E: Arg, CheckLoc: EqualLoc);
304 Arg = MaybeCreateExprWithCleanups(SubExpr: Arg);
305
306 return Arg;
307}
308
309void Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
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
317 = UnparsedDefaultArgInstantiations.find(Val: Param);
318 if (InstPos != UnparsedDefaultArgInstantiations.end()) {
319 for (auto &Instantiation : InstPos->second)
320 Instantiation->setUninstantiatedDefaultArg(Arg);
321
322 // We're done tracking this parameter's instantiations.
323 UnparsedDefaultArgInstantiations.erase(I: InstPos);
324 }
325}
326
327void
328Sema::ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc,
329 Expr *DefaultArg) {
330 if (!param || !DefaultArg)
331 return;
332
333 ParmVarDecl *Param = cast<ParmVarDecl>(Val: param);
334 UnparsedDefaultArgLocs.erase(Val: Param);
335
336 // Default arguments are only permitted in C++
337 if (!getLangOpts().CPlusPlus) {
338 Diag(Loc: EqualLoc, DiagID: diag::err_param_default_argument)
339 << DefaultArg->getSourceRange();
340 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
341 }
342
343 // Check for unexpanded parameter packs.
344 if (DiagnoseUnexpandedParameterPack(E: DefaultArg, UPPC: UPPC_DefaultArgument))
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(Loc: EqualLoc, DiagID: 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, Arg: 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(S: DefaultArg))
367 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
368
369 SetParamDefaultArgument(Param, Arg: DefaultArg, EqualLoc);
370}
371
372void Sema::ActOnParamUnparsedDefaultArgument(Decl *param,
373 SourceLocation EqualLoc,
374 SourceLocation ArgLoc) {
375 if (!param)
376 return;
377
378 ParmVarDecl *Param = cast<ParmVarDecl>(Val: param);
379 Param->setUnparsedDefaultArg();
380 UnparsedDefaultArgLocs[Param] = ArgLoc;
381}
382
383void Sema::ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc,
384 Expr *DefaultArg) {
385 if (!param)
386 return;
387
388 ParmVarDecl *Param = cast<ParmVarDecl>(Val: param);
389 Param->setInvalidDecl();
390 UnparsedDefaultArgLocs.erase(Val: Param);
391 ExprResult RE;
392 if (DefaultArg) {
393 RE = CreateRecoveryExpr(Begin: EqualLoc, End: DefaultArg->getEndLoc(), SubExprs: {DefaultArg},
394 T: Param->getType().getNonReferenceType());
395 } else {
396 RE = CreateRecoveryExpr(Begin: EqualLoc, End: EqualLoc, SubExprs: {},
397 T: Param->getType().getNonReferenceType());
398 }
399 Param->setDefaultArg(RE.get());
400}
401
402void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
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>(Val: 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(Loc: Param->getLocation(), DiagID: diag::err_param_default_argument_nonfunc)
434 << SR;
435 } else if (Param->getDefaultArg()) {
436 Diag(Loc: Param->getLocation(), DiagID: 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
447static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) {
448 return llvm::any_of(Range: FD->parameters(), P: [](ParmVarDecl *P) {
449 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
450 });
451}
452
453bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old,
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(SemaRef&: *this, D: PrevForDefaultArgs))
474 continue;
475
476 if (S && !isDeclInScope(D: PrevForDefaultArgs, Ctx: 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(i: p);
519 ParmVarDecl *NewParam = New->getParamDecl(i: 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>(Val: New);
533 if (MD && MD->getParent()->getDescribedClassTemplate()) {
534 // Merge the old default argument into the new parameter.
535 NewParam->setHasInheritedDefaultArg();
536 if (OldParam->hasUninstantiatedDefaultArg())
537 NewParam->setUninstantiatedDefaultArg(
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(Loc: NewParam->getLocation(), DiagID: 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(i: p);
563 }
564
565 Diag(Loc: OldParam->getLocation(), DiagID: 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())
580 NewParam->setUninstantiatedDefaultArg(
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(Loc: NewParam->getLocation(),
589 DiagID: diag::err_param_default_argument_template_redecl)
590 << NewParam->getDefaultArgRange();
591 Diag(Loc: PrevForDefaultArgs->getLocation(),
592 DiagID: diag::note_template_prev_declaration)
593 << false;
594 } else if (New->getTemplateSpecializationKind()
595 != TSK_ImplicitInstantiation &&
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(Loc: NewParam->getLocation(), DiagID: 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;
621 if (CXXRecordDecl *Record
622 = dyn_cast<CXXRecordDecl>(Val: New->getDeclContext())) {
623 if (Record->getDescribedClassTemplate())
624 WhichKind = 0;
625 else if (isa<ClassTemplatePartialSpecializationDecl>(Val: Record))
626 WhichKind = 1;
627 else
628 WhichKind = 2;
629 }
630
631 Diag(Loc: NewParam->getLocation(),
632 DiagID: 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>(Val: New) &&
643 New->getMinRequiredArguments() < Old->getMinRequiredArguments()) {
644 CXXSpecialMemberKind NewSM = getSpecialMember(MD: cast<CXXMethodDecl>(Val: New)),
645 OldSM = getSpecialMember(MD: cast<CXXMethodDecl>(Val: Old));
646 if (NewSM != OldSM) {
647 ParmVarDecl *NewParam = New->getParamDecl(i: New->getMinRequiredArguments());
648 assert(NewParam->hasDefaultArg());
649 Diag(Loc: NewParam->getLocation(), DiagID: diag::err_default_arg_makes_ctor_special)
650 << NewParam->getDefaultArgRange() << NewSM;
651 Diag(Loc: Old->getLocation(), DiagID: 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(Loc: New->getLocation(), DiagID: diag::err_constexpr_redecl_mismatch)
661 << New << static_cast<int>(New->getConstexprKind())
662 << static_cast<int>(Old->getConstexprKind());
663 Diag(Loc: Old->getLocation(), DiagID: diag::note_previous_declaration);
664 Invalid = true;
665 } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
666 Old->isDefined(Definition&: 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(Loc: New->getLocation(), DiagID: diag::err_inline_decl_follows_def) << New;
676 Diag(Loc: Def->getLocation(), DiagID: 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>(Val: New) &&
685 !New->isFunctionTemplateSpecialization() && isVisible(D: Old)) {
686 Diag(Loc: New->getLocation(), DiagID: diag::err_deduction_guide_redeclared);
687 Diag(Loc: Old->getLocation(), DiagID: 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.
694 if (Old->getFriendObjectKind() == Decl::FOK_Undeclared &&
695 functionDeclHasDefaultArgument(FD: Old)) {
696 Diag(Loc: New->getLocation(), DiagID: diag::err_friend_decl_with_def_arg_redeclared);
697 Diag(Loc: Old->getLocation(), DiagID: 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(Definition&: OldDefinition, CheckForPendingFriendDefinition: true))
710 CheckForFunctionRedefinition(FD: New, EffectiveDefinition: OldDefinition);
711
712 return Invalid;
713}
714
715void Sema::DiagPlaceholderVariableDefinition(SourceLocation Loc) {
716 Diag(Loc, DiagID: getLangOpts().CPlusPlus26
717 ? diag::warn_cxx23_placeholder_var_definition
718 : diag::ext_placeholder_var_definition);
719}
720
721NamedDecl *
722Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,
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(Loc: Decomp.getLSquareLoc(), DiagID: 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(Loc: TemplateParamLists.front()->getTemplateLoc(),
743 DiagID: diag::err_decomp_decl_template);
744 return nullptr;
745 }
746
747 unsigned DiagID;
748 if (!getLangOpts().CPlusPlus17)
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(Loc: 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 // C++23 [dcl.pre]/7:
772 // Each decl-specifier in the decl-specifier-seq shall be constexpr,
773 // constinit, static, thread_local, auto, or a cv-qualifier
774 auto &DS = D.getDeclSpec();
775 auto DiagBadSpecifier = [&](StringRef Name, SourceLocation Loc) {
776 Diag(Loc, DiagID: diag::err_decomp_decl_spec) << Name;
777 };
778
779 auto DiagCpp20Specifier = [&](StringRef Name, SourceLocation Loc) {
780 DiagCompat(Loc, CompatDiagId: diag_compat::decomp_decl_spec) << Name;
781 };
782
783 if (auto SCS = DS.getStorageClassSpec()) {
784 if (SCS == DeclSpec::SCS_static)
785 DiagCpp20Specifier(DeclSpec::getSpecifierName(S: SCS),
786 DS.getStorageClassSpecLoc());
787 else
788 DiagBadSpecifier(DeclSpec::getSpecifierName(S: SCS),
789 DS.getStorageClassSpecLoc());
790 }
791 if (auto TSCS = DS.getThreadStorageClassSpec())
792 DiagCpp20Specifier(DeclSpec::getSpecifierName(S: TSCS),
793 DS.getThreadStorageClassSpecLoc());
794
795 if (DS.isInlineSpecified())
796 DiagBadSpecifier("inline", DS.getInlineSpecLoc());
797
798 if (ConstexprSpecKind ConstexprSpec = DS.getConstexprSpecifier();
799 ConstexprSpec != ConstexprSpecKind::Unspecified) {
800 if (ConstexprSpec == ConstexprSpecKind::Consteval ||
801 !getLangOpts().CPlusPlus26)
802 DiagBadSpecifier(DeclSpec::getSpecifierName(C: ConstexprSpec),
803 DS.getConstexprSpecLoc());
804 }
805
806 // We can't recover from it being declared as a typedef.
807 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
808 return nullptr;
809
810 // C++2a [dcl.struct.bind]p1:
811 // A cv that includes volatile is deprecated
812 if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) &&
813 getLangOpts().CPlusPlus20)
814 Diag(Loc: DS.getVolatileSpecLoc(),
815 DiagID: diag::warn_deprecated_volatile_structured_binding);
816
817 TypeSourceInfo *TInfo = GetTypeForDeclarator(D);
818 QualType R = TInfo->getType();
819
820 if (DiagnoseUnexpandedParameterPack(Loc: D.getIdentifierLoc(), T: TInfo,
821 UPPC: UPPC_DeclarationType))
822 D.setInvalidType();
823
824 // The syntax only allows a single ref-qualifier prior to the decomposition
825 // declarator. No other declarator chunks are permitted. Also check the type
826 // specifier here.
827 if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
828 D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
829 (D.getNumTypeObjects() == 1 &&
830 D.getTypeObject(i: 0).Kind != DeclaratorChunk::Reference)) {
831 Diag(Loc: Decomp.getLSquareLoc(),
832 DiagID: (D.hasGroupingParens() ||
833 (D.getNumTypeObjects() &&
834 D.getTypeObject(i: 0).Kind == DeclaratorChunk::Paren))
835 ? diag::err_decomp_decl_parens
836 : diag::err_decomp_decl_type)
837 << R;
838
839 // In most cases, there's no actual problem with an explicitly-specified
840 // type, but a function type won't work here, and ActOnVariableDeclarator
841 // shouldn't be called for such a type.
842 if (R->isFunctionType())
843 D.setInvalidType();
844 }
845
846 // Constrained auto is prohibited by [decl.pre]p6, so check that here.
847 if (DS.isConstrainedAuto()) {
848 TemplateIdAnnotation *TemplRep = DS.getRepAsTemplateId();
849 assert(TemplRep->Kind == TNK_Concept_template &&
850 "No other template kind should be possible for a constrained auto");
851
852 SourceRange TemplRange{TemplRep->TemplateNameLoc,
853 TemplRep->RAngleLoc.isValid()
854 ? TemplRep->RAngleLoc
855 : TemplRep->TemplateNameLoc};
856 Diag(Loc: TemplRep->TemplateNameLoc, DiagID: diag::err_decomp_decl_constraint)
857 << TemplRange << FixItHint::CreateRemoval(RemoveRange: TemplRange);
858 }
859
860 // Build the BindingDecls.
861 SmallVector<BindingDecl*, 8> Bindings;
862
863 // Build the BindingDecls.
864 for (auto &B : D.getDecompositionDeclarator().bindings()) {
865 // Check for name conflicts.
866 DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
867 IdentifierInfo *VarName = B.Name;
868 assert(VarName && "Cannot have an unnamed binding declaration");
869
870 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
871 RedeclarationKind::ForVisibleRedeclaration);
872 LookupName(R&: Previous, S,
873 /*CreateBuiltins*/AllowBuiltinCreation: DC->getRedeclContext()->isTranslationUnit());
874
875 // It's not permitted to shadow a template parameter name.
876 if (Previous.isSingleResult() &&
877 Previous.getFoundDecl()->isTemplateParameter()) {
878 DiagnoseTemplateParameterShadow(Loc: B.NameLoc, PrevDecl: Previous.getFoundDecl());
879 Previous.clear();
880 }
881
882 QualType QT;
883 if (B.EllipsisLoc.isValid()) {
884 if (!cast<Decl>(Val: DC)->isTemplated())
885 Diag(Loc: B.EllipsisLoc, DiagID: diag::err_pack_outside_template);
886 QT = Context.getPackExpansionType(Pattern: Context.DependentTy, NumExpansions: std::nullopt,
887 /*ExpectsPackInType=*/ExpectPackInType: false);
888 }
889
890 auto *BD = BindingDecl::Create(C&: Context, DC, IdLoc: B.NameLoc, Id: B.Name, T: QT);
891
892 ProcessDeclAttributeList(S, D: BD, AttrList: *B.Attrs);
893
894 // Find the shadowed declaration before filtering for scope.
895 NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()
896 ? getShadowedDeclaration(D: BD, R: Previous)
897 : nullptr;
898
899 bool ConsiderLinkage = DC->isFunctionOrMethod() &&
900 DS.getStorageClassSpec() == DeclSpec::SCS_extern;
901 FilterLookupForScope(R&: Previous, Ctx: DC, S, ConsiderLinkage,
902 /*AllowInlineNamespace*/false);
903
904 bool IsPlaceholder = DS.getStorageClassSpec() != DeclSpec::SCS_static &&
905 DC->isFunctionOrMethod() && VarName->isPlaceholder();
906 if (!Previous.empty()) {
907 if (IsPlaceholder) {
908 bool sameDC = (Previous.end() - 1)
909 ->getDeclContext()
910 ->getRedeclContext()
911 ->Equals(DC: DC->getRedeclContext());
912 if (sameDC &&
913 isDeclInScope(D: *(Previous.end() - 1), Ctx: CurContext, S, AllowInlineNamespace: false)) {
914 Previous.clear();
915 DiagPlaceholderVariableDefinition(Loc: B.NameLoc);
916 }
917 } else {
918 auto *Old = Previous.getRepresentativeDecl();
919 Diag(Loc: B.NameLoc, DiagID: diag::err_redefinition) << B.Name;
920 Diag(Loc: Old->getLocation(), DiagID: diag::note_previous_definition);
921 }
922 } else if (ShadowedDecl && !D.isRedeclaration()) {
923 CheckShadow(D: BD, ShadowedDecl, R: Previous);
924 }
925 PushOnScopeChains(D: BD, S, AddToContext: true);
926 Bindings.push_back(Elt: BD);
927 ParsingInitForAutoVars.insert(Ptr: BD);
928 }
929
930 // There are no prior lookup results for the variable itself, because it
931 // is unnamed.
932 DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
933 Decomp.getLSquareLoc());
934 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
935 RedeclarationKind::ForVisibleRedeclaration);
936
937 // Build the variable that holds the non-decomposed object.
938 bool AddToScope = true;
939 NamedDecl *New =
940 ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
941 TemplateParamLists: MultiTemplateParamsArg(), AddToScope, Bindings);
942 if (AddToScope) {
943 S->AddDecl(D: New);
944 CurContext->addHiddenDecl(D: New);
945 }
946
947 if (OpenMP().isInOpenMPDeclareTargetContext())
948 OpenMP().checkDeclIsAllowedInOpenMPTarget(E: nullptr, D: New);
949
950 return New;
951}
952
953// Check the arity of the structured bindings.
954// Create the resolved pack expr if needed.
955static bool CheckBindingsCount(Sema &S, DecompositionDecl *DD,
956 QualType DecompType,
957 ArrayRef<BindingDecl *> Bindings,
958 unsigned MemberCount) {
959 auto BindingWithPackItr = llvm::find_if(
960 Range&: Bindings, P: [](BindingDecl *D) -> bool { return D->isParameterPack(); });
961 bool HasPack = BindingWithPackItr != Bindings.end();
962 bool IsValid;
963 if (!HasPack) {
964 IsValid = Bindings.size() == MemberCount;
965 } else {
966 // There may not be more members than non-pack bindings.
967 IsValid = MemberCount >= Bindings.size() - 1;
968 }
969
970 if (IsValid && HasPack) {
971 // Create the pack expr and assign it to the binding.
972 unsigned PackSize = MemberCount - Bindings.size() + 1;
973
974 BindingDecl *BPack = *BindingWithPackItr;
975 BPack->setDecomposedDecl(DD);
976 SmallVector<ValueDecl *, 8> NestedBDs(PackSize);
977 // Create the nested BindingDecls.
978 for (unsigned I = 0; I < PackSize; ++I) {
979 BindingDecl *NestedBD = BindingDecl::Create(
980 C&: S.Context, DC: BPack->getDeclContext(), IdLoc: BPack->getLocation(),
981 Id: BPack->getIdentifier(), T: QualType());
982 NestedBD->setDecomposedDecl(DD);
983 NestedBDs[I] = NestedBD;
984 }
985
986 QualType PackType = S.Context.getPackExpansionType(
987 Pattern: S.Context.DependentTy, NumExpansions: PackSize, /*ExpectsPackInType=*/ExpectPackInType: false);
988 auto *PackExpr = FunctionParmPackExpr::Create(
989 Context: S.Context, T: PackType, ParamPack: BPack, NameLoc: BPack->getBeginLoc(), Params: NestedBDs);
990 BPack->setBinding(DeclaredType: PackType, Binding: PackExpr);
991 }
992
993 if (IsValid)
994 return false;
995
996 S.Diag(Loc: DD->getLocation(), DiagID: diag::err_decomp_decl_wrong_number_bindings)
997 << DecompType << (unsigned)Bindings.size() << MemberCount << MemberCount
998 << (MemberCount < Bindings.size());
999 return true;
1000}
1001
1002static bool checkSimpleDecomposition(
1003 Sema &S, ArrayRef<BindingDecl *> Bindings, ValueDecl *Src,
1004 QualType DecompType, const llvm::APSInt &NumElemsAPS, QualType ElemType,
1005 llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
1006 unsigned NumElems = (unsigned)NumElemsAPS.getLimitedValue(UINT_MAX);
1007 auto *DD = cast<DecompositionDecl>(Val: Src);
1008
1009 if (CheckBindingsCount(S, DD, DecompType, Bindings, MemberCount: NumElems))
1010 return true;
1011
1012 unsigned I = 0;
1013 for (auto *B : DD->flat_bindings()) {
1014 SourceLocation Loc = B->getLocation();
1015 ExprResult E = S.BuildDeclRefExpr(D: Src, Ty: DecompType, VK: VK_LValue, Loc);
1016 if (E.isInvalid())
1017 return true;
1018 E = GetInit(Loc, E.get(), I++);
1019 if (E.isInvalid())
1020 return true;
1021 B->setBinding(DeclaredType: ElemType, Binding: E.get());
1022 }
1023
1024 return false;
1025}
1026
1027static bool checkArrayLikeDecomposition(Sema &S,
1028 ArrayRef<BindingDecl *> Bindings,
1029 ValueDecl *Src, QualType DecompType,
1030 const llvm::APSInt &NumElems,
1031 QualType ElemType) {
1032 return checkSimpleDecomposition(
1033 S, Bindings, Src, DecompType, NumElemsAPS: NumElems, ElemType,
1034 GetInit: [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
1035 ExprResult E = S.ActOnIntegerConstant(Loc, Val: I);
1036 if (E.isInvalid())
1037 return ExprError();
1038 return S.CreateBuiltinArraySubscriptExpr(Base, LLoc: Loc, Idx: E.get(), RLoc: Loc);
1039 });
1040}
1041
1042static bool checkArrayDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
1043 ValueDecl *Src, QualType DecompType,
1044 const ConstantArrayType *CAT) {
1045 return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
1046 NumElems: llvm::APSInt(CAT->getSize()),
1047 ElemType: CAT->getElementType());
1048}
1049
1050static bool checkVectorDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
1051 ValueDecl *Src, QualType DecompType,
1052 const VectorType *VT) {
1053 return checkArrayLikeDecomposition(
1054 S, Bindings, Src, DecompType, NumElems: llvm::APSInt::get(X: VT->getNumElements()),
1055 ElemType: S.Context.getQualifiedType(T: VT->getElementType(),
1056 Qs: DecompType.getQualifiers()));
1057}
1058
1059static bool checkComplexDecomposition(Sema &S,
1060 ArrayRef<BindingDecl *> Bindings,
1061 ValueDecl *Src, QualType DecompType,
1062 const ComplexType *CT) {
1063 return checkSimpleDecomposition(
1064 S, Bindings, Src, DecompType, NumElemsAPS: llvm::APSInt::get(X: 2),
1065 ElemType: S.Context.getQualifiedType(T: CT->getElementType(),
1066 Qs: DecompType.getQualifiers()),
1067 GetInit: [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
1068 return S.CreateBuiltinUnaryOp(OpLoc: Loc, Opc: I ? UO_Imag : UO_Real, InputExpr: Base);
1069 });
1070}
1071
1072static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy,
1073 TemplateArgumentListInfo &Args,
1074 const TemplateParameterList *Params) {
1075 SmallString<128> SS;
1076 llvm::raw_svector_ostream OS(SS);
1077 bool First = true;
1078 unsigned I = 0;
1079 for (auto &Arg : Args.arguments()) {
1080 if (!First)
1081 OS << ", ";
1082 Arg.getArgument().print(Policy: PrintingPolicy, Out&: OS,
1083 IncludeType: TemplateParameterList::shouldIncludeTypeForArgument(
1084 Policy: PrintingPolicy, TPL: Params, Idx: I));
1085 First = false;
1086 I++;
1087 }
1088 return std::string(OS.str());
1089}
1090
1091static QualType getStdTrait(Sema &S, SourceLocation Loc, StringRef Trait,
1092 TemplateArgumentListInfo &Args, unsigned DiagID) {
1093 auto DiagnoseMissing = [&] {
1094 if (DiagID)
1095 S.Diag(Loc, DiagID) << printTemplateArgs(PrintingPolicy: S.Context.getPrintingPolicy(),
1096 Args, /*Params*/ nullptr);
1097 return QualType();
1098 };
1099
1100 // FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
1101 NamespaceDecl *Std = S.getStdNamespace();
1102 if (!Std)
1103 return DiagnoseMissing();
1104
1105 // Look up the trait itself, within namespace std. We can diagnose various
1106 // problems with this lookup even if we've been asked to not diagnose a
1107 // missing specialization, because this can only fail if the user has been
1108 // declaring their own names in namespace std or we don't support the
1109 // standard library implementation in use.
1110 LookupResult Result(S, &S.PP.getIdentifierTable().get(Name: Trait), Loc,
1111 Sema::LookupOrdinaryName);
1112 if (!S.LookupQualifiedName(R&: Result, LookupCtx: Std))
1113 return DiagnoseMissing();
1114 if (Result.isAmbiguous())
1115 return QualType();
1116
1117 ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
1118 if (!TraitTD) {
1119 Result.suppressDiagnostics();
1120 NamedDecl *Found = *Result.begin();
1121 S.Diag(Loc, DiagID: diag::err_std_type_trait_not_class_template) << Trait;
1122 S.Diag(Loc: Found->getLocation(), DiagID: diag::note_declared_at);
1123 return QualType();
1124 }
1125
1126 // Build the template-id.
1127 QualType TraitTy = S.CheckTemplateIdType(
1128 Keyword: ElaboratedTypeKeyword::None, Template: TemplateName(TraitTD), TemplateLoc: Loc, TemplateArgs&: Args,
1129 /*Scope=*/nullptr, /*ForNestedNameSpecifier=*/false);
1130 if (TraitTy.isNull())
1131 return QualType();
1132
1133 if (!S.isCompleteType(Loc, T: TraitTy)) {
1134 if (DiagID)
1135 S.RequireCompleteType(
1136 Loc, T: TraitTy, DiagID,
1137 Args: printTemplateArgs(PrintingPolicy: S.Context.getPrintingPolicy(), Args,
1138 Params: TraitTD->getTemplateParameters()));
1139 return QualType();
1140 }
1141 return TraitTy;
1142}
1143
1144static bool lookupMember(Sema &S, CXXRecordDecl *RD,
1145 LookupResult &MemberLookup) {
1146 assert(RD && "specialization of class template is not a class?");
1147 S.LookupQualifiedName(R&: MemberLookup, LookupCtx: RD);
1148 return MemberLookup.isAmbiguous();
1149}
1150
1151static TemplateArgumentLoc
1152getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T,
1153 uint64_t I) {
1154 TemplateArgument Arg(S.Context, S.Context.MakeIntValue(Value: I, Type: T), T);
1155 return S.getTrivialTemplateArgumentLoc(Arg, NTTPType: T, Loc);
1156}
1157
1158static TemplateArgumentLoc
1159getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T) {
1160 return S.getTrivialTemplateArgumentLoc(Arg: TemplateArgument(T), NTTPType: QualType(), Loc);
1161}
1162
1163namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }
1164
1165static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T,
1166 unsigned &OutSize) {
1167 EnterExpressionEvaluationContext ContextRAII(
1168 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
1169
1170 // Form template argument list for tuple_size<T>.
1171 TemplateArgumentListInfo Args(Loc, Loc);
1172 Args.addArgument(Loc: getTrivialTypeTemplateArgument(S, Loc, T));
1173
1174 QualType TraitTy = getStdTrait(S, Loc, Trait: "tuple_size", Args, /*DiagID=*/0);
1175 if (TraitTy.isNull())
1176 return IsTupleLike::NotTupleLike;
1177
1178 DeclarationName Value = S.PP.getIdentifierInfo(Name: "value");
1179 LookupResult R(S, Value, Loc, Sema::LookupOrdinaryName);
1180
1181 // If there's no tuple_size specialization or the lookup of 'value' is empty,
1182 // it's not tuple-like.
1183 if (lookupMember(S, RD: TraitTy->getAsCXXRecordDecl(), MemberLookup&: R) || R.empty())
1184 return IsTupleLike::NotTupleLike;
1185
1186 // If we get this far, we've committed to the tuple interpretation, but
1187 // we can still fail if there actually isn't a usable ::value.
1188
1189 struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
1190 LookupResult &R;
1191 TemplateArgumentListInfo &Args;
1192 ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
1193 : R(R), Args(Args) {}
1194 Sema::SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
1195 SourceLocation Loc) override {
1196 return S.Diag(Loc, DiagID: diag::err_decomp_decl_std_tuple_size_not_constant)
1197 << printTemplateArgs(PrintingPolicy: S.Context.getPrintingPolicy(), Args,
1198 /*Params*/ nullptr);
1199 }
1200 } Diagnoser(R, Args);
1201
1202 ExprResult E =
1203 S.BuildDeclarationNameExpr(SS: CXXScopeSpec(), R, /*NeedsADL*/false);
1204 if (E.isInvalid())
1205 return IsTupleLike::Error;
1206
1207 llvm::APSInt Size;
1208 E = S.VerifyIntegerConstantExpression(E: E.get(), Result: &Size, Diagnoser);
1209 if (E.isInvalid())
1210 return IsTupleLike::Error;
1211
1212 // The implementation limit is UINT_MAX-1, to allow this to be passed down on
1213 // an UnsignedOrNone.
1214 if (Size < 0 || Size >= UINT_MAX) {
1215 llvm::SmallVector<char, 16> Str;
1216 Size.toString(Str);
1217 S.Diag(Loc, DiagID: diag::err_decomp_decl_std_tuple_size_invalid)
1218 << printTemplateArgs(PrintingPolicy: S.Context.getPrintingPolicy(), Args,
1219 /*Params=*/nullptr)
1220 << StringRef(Str.data(), Str.size());
1221 return IsTupleLike::Error;
1222 }
1223
1224 OutSize = Size.getExtValue();
1225 return IsTupleLike::TupleLike;
1226}
1227
1228/// \return std::tuple_element<I, T>::type.
1229static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc,
1230 unsigned I, QualType T) {
1231 // Form template argument list for tuple_element<I, T>.
1232 TemplateArgumentListInfo Args(Loc, Loc);
1233 Args.addArgument(
1234 Loc: getTrivialIntegralTemplateArgument(S, Loc, T: S.Context.getSizeType(), I));
1235 Args.addArgument(Loc: getTrivialTypeTemplateArgument(S, Loc, T));
1236
1237 QualType TraitTy =
1238 getStdTrait(S, Loc, Trait: "tuple_element", Args,
1239 DiagID: diag::err_decomp_decl_std_tuple_element_not_specialized);
1240 if (TraitTy.isNull())
1241 return QualType();
1242
1243 DeclarationName TypeDN = S.PP.getIdentifierInfo(Name: "type");
1244 LookupResult R(S, TypeDN, Loc, Sema::LookupOrdinaryName);
1245 if (lookupMember(S, RD: TraitTy->getAsCXXRecordDecl(), MemberLookup&: R))
1246 return QualType();
1247
1248 auto *TD = R.getAsSingle<TypeDecl>();
1249 if (!TD) {
1250 R.suppressDiagnostics();
1251 S.Diag(Loc, DiagID: diag::err_decomp_decl_std_tuple_element_not_specialized)
1252 << printTemplateArgs(PrintingPolicy: S.Context.getPrintingPolicy(), Args,
1253 /*Params*/ nullptr);
1254 if (!R.empty())
1255 S.Diag(Loc: R.getRepresentativeDecl()->getLocation(), DiagID: diag::note_declared_at);
1256 return QualType();
1257 }
1258
1259 NestedNameSpecifier Qualifier(TraitTy.getTypePtr());
1260 return S.Context.getTypeDeclType(Keyword: ElaboratedTypeKeyword::None, Qualifier, Decl: TD);
1261}
1262
1263namespace {
1264struct InitializingBinding {
1265 Sema &S;
1266 InitializingBinding(Sema &S, BindingDecl *BD) : S(S) {
1267 Sema::CodeSynthesisContext Ctx;
1268 Ctx.Kind = Sema::CodeSynthesisContext::InitializingStructuredBinding;
1269 Ctx.PointOfInstantiation = BD->getLocation();
1270 Ctx.Entity = BD;
1271 S.pushCodeSynthesisContext(Ctx);
1272 }
1273 ~InitializingBinding() {
1274 S.popCodeSynthesisContext();
1275 }
1276};
1277}
1278
1279static bool checkTupleLikeDecomposition(Sema &S,
1280 ArrayRef<BindingDecl *> Bindings,
1281 VarDecl *Src, QualType DecompType,
1282 unsigned NumElems) {
1283 auto *DD = cast<DecompositionDecl>(Val: Src);
1284 if (CheckBindingsCount(S, DD, DecompType, Bindings, MemberCount: NumElems))
1285 return true;
1286
1287 if (Bindings.empty())
1288 return false;
1289
1290 DeclarationName GetDN = S.PP.getIdentifierInfo(Name: "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(Loc: Src->getLocation(), T: DecompType)) {
1298 if (auto *RD = DecompType->getAsCXXRecordDecl())
1299 S.LookupQualifiedName(R&: MemberGet, LookupCtx: 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>(Val: D->getUnderlyingDecl())) {
1307 TemplateParameterList *TPL = FTD->getTemplateParameters();
1308 if (TPL->size() != 0 &&
1309 isa<NonTypeTemplateParmDecl>(Val: TPL->getParam(Idx: 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(D: Src, Ty: DecompType, VK: 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(Context: S.Context, T: E.get()->getType(), Kind: CK_NoOp,
1331 Operand: E.get(), BasePath: nullptr, Cat: VK_XValue,
1332 FPO: FPOptionsOverride());
1333
1334 TemplateArgumentListInfo Args(Loc, Loc);
1335 Args.addArgument(
1336 Loc: getTrivialIntegralTemplateArgument(S, Loc, T: S.Context.getSizeType(), I));
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(Base: E.get(), BaseType: DecompType, OpLoc: Loc, IsArrow: false,
1342 SS: CXXScopeSpec(), TemplateKWLoc: SourceLocation(), FirstQualifierInScope: nullptr,
1343 R&: MemberGet, TemplateArgs: &Args, S: nullptr);
1344 if (E.isInvalid())
1345 return true;
1346
1347 E = S.BuildCallExpr(S: nullptr, Fn: E.get(), LParenLoc: Loc, ArgExprs: {}, RParenLoc: Loc);
1348 } else {
1349 // Otherwise, the initializer is get<i-1>(e), where get is looked up
1350 // in the associated namespaces.
1351 Expr *Get = UnresolvedLookupExpr::Create(
1352 Context: S.Context, NamingClass: nullptr, QualifierLoc: NestedNameSpecifierLoc(), TemplateKWLoc: SourceLocation(),
1353 NameInfo: DeclarationNameInfo(GetDN, Loc), /*RequiresADL=*/true, Args: &Args,
1354 Begin: UnresolvedSetIterator(), End: UnresolvedSetIterator(),
1355 /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false);
1356
1357 Expr *Arg = E.get();
1358 E = S.BuildCallExpr(S: nullptr, Fn: Get, LParenLoc: Loc, ArgExprs: Arg, RParenLoc: 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, T: 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, LValueRef: E.get()->isLValue(), Loc, Entity: 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 =
1380 VarDecl::Create(C&: S.Context, DC: Src->getDeclContext(), StartLoc: Loc, IdLoc: Loc,
1381 Id: B->getDeclName().getAsIdentifierInfo(), T: RefType,
1382 /*TInfo=*/nullptr, S: 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(D: RefVD);
1389
1390 InitializedEntity Entity = InitializedEntity::InitializeBinding(Binding: RefVD);
1391 InitializationKind Kind = InitializationKind::CreateCopy(InitLoc: Loc, EqualLoc: Loc);
1392 InitializationSequence Seq(S, Entity, Kind, Init);
1393 E = Seq.Perform(S, Entity, Kind, Args: Init);
1394 if (E.isInvalid())
1395 return true;
1396 E = S.ActOnFinishFullExpr(Expr: E.get(), CC: Loc, /*DiscardedValue*/ false);
1397 if (E.isInvalid())
1398 return true;
1399 RefVD->setInit(E.get());
1400 S.CheckCompleteVariableDeclaration(VD: RefVD);
1401
1402 E = S.BuildDeclarationNameExpr(SS: CXXScopeSpec(),
1403 NameInfo: DeclarationNameInfo(B->getDeclName(), Loc),
1404 D: RefVD);
1405 if (E.isInvalid())
1406 return true;
1407
1408 B->setBinding(DeclaredType: T, Binding: 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++.
1418static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc,
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;
1427 AccessSpecifier AS = AS_public;
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(BaseMatches: 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(D: const_cast<CXXRecordDecl*>(RD), AS: 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(T1: P.back().Base->getType(),
1448 T2: BestPath->back().Base->getType())) {
1449 // ... the same ...
1450 S.Diag(Loc, DiagID: 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(BaseType: S.Context.getCanonicalType(T: BaseType))) {
1462 S.Diag(Loc, DiagID: 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.
1468 S.CheckBaseClassAccess(AccessLoc: Loc, Base: BaseType, Derived: S.Context.getCanonicalTagType(TD: RD),
1469 Path: *BestPath, DiagID: 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(BaseMatches: BaseHasFields, Paths)) {
1480 S.Diag(Loc, DiagID: 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(D: const_cast<CXXRecordDecl*>(ClassWithFields), AS);
1487}
1488
1489static bool CheckMemberDecompositionFields(Sema &S, SourceLocation Loc,
1490 const CXXRecordDecl *OrigRD,
1491 QualType DecompType,
1492 DeclAccessPair BasePair) {
1493 const auto *RD = cast_or_null<CXXRecordDecl>(Val: 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, DiagID: diag::err_decomp_decl_lambda);
1506 S.Diag(Loc: RD->getLocation(), DiagID: diag::note_lambda_decl);
1507 return true;
1508 }
1509
1510 if (FD->isAnonymousStructOrUnion()) {
1511 S.Diag(Loc, DiagID: diag::err_decomp_decl_anon_union_member)
1512 << DecompType << FD->getType()->isUnionType();
1513 S.Diag(Loc: FD->getLocation(), DiagID: 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.
1523 S.CheckStructuredBindingMemberAccess(
1524 UseLoc: Loc, DecomposedClass: const_cast<CXXRecordDecl *>(OrigRD),
1525 Field: DeclAccessPair::make(D: FD, AS: CXXRecordDecl::MergeAccess(
1526 PathAccess: BasePair.getAccess(), DeclAccess: FD->getAccess())));
1527 }
1528 return false;
1529}
1530
1531static bool checkMemberDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
1532 ValueDecl *Src, QualType DecompType,
1533 const CXXRecordDecl *OrigRD) {
1534 if (S.RequireCompleteType(Loc: Src->getLocation(), T: DecompType,
1535 DiagID: diag::err_incomplete_type))
1536 return true;
1537
1538 CXXCastPath BasePath;
1539 DeclAccessPair BasePair =
1540 findDecomposableBaseClass(S, Loc: Src->getLocation(), RD: OrigRD, BasePath);
1541 const auto *RD = cast_or_null<CXXRecordDecl>(Val: BasePair.getDecl());
1542 if (!RD)
1543 return true;
1544 QualType BaseType = S.Context.getQualifiedType(
1545 T: S.Context.getCanonicalTagType(TD: RD), Qs: DecompType.getQualifiers());
1546
1547 auto *DD = cast<DecompositionDecl>(Val: Src);
1548 unsigned NumFields = llvm::count_if(
1549 Range: RD->fields(), P: [](FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1550 if (CheckBindingsCount(S, DD, DecompType, Bindings, MemberCount: 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, Loc: 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++);
1571 SourceLocation Loc = B->getLocation();
1572
1573 // Initialize the binding to Src.FD.
1574 ExprResult E = S.BuildDeclRefExpr(D: Src, Ty: DecompType, VK: VK_LValue, Loc);
1575 if (E.isInvalid())
1576 return true;
1577 E = S.ImpCastExprToType(E: E.get(), Type: BaseType, CK: CK_UncheckedDerivedToBase,
1578 VK: VK_LValue, BasePath: &BasePath);
1579 if (E.isInvalid())
1580 return true;
1581 E = S.BuildFieldReferenceExpr(BaseExpr: E.get(), /*IsArrow*/ false, OpLoc: Loc,
1582 SS: CXXScopeSpec(), Field: FD,
1583 FoundDecl: DeclAccessPair::make(D: FD, AS: FD->getAccess()),
1584 MemberNameInfo: 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(DeclaredType: S.BuildQualifiedType(T: FD->getType(), Loc, Qs: Q), Binding: E.get());
1597 }
1598
1599 return false;
1600}
1601
1602void Sema::CheckCompleteDecompositionDeclaration(DecompositionDecl *DD) {
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();
1618 ArrayRef<BindingDecl*> Bindings = DD->bindings();
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(T: DecompType)) {
1625 if (checkArrayDecomposition(S&: *this, Bindings, Src: DD, DecompType, CAT))
1626 DD->setInvalidDecl();
1627 return;
1628 }
1629 if (auto *VT = DecompType->getAs<VectorType>()) {
1630 if (checkVectorDecomposition(S&: *this, Bindings, Src: DD, DecompType, VT))
1631 DD->setInvalidDecl();
1632 return;
1633 }
1634 if (auto *CT = DecompType->getAs<ComplexType>()) {
1635 if (checkComplexDecomposition(S&: *this, Bindings, Src: 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 unsigned TupleSize;
1644 switch (isTupleLike(S&: *this, Loc: DD->getLocation(), T: DecompType, OutSize&: TupleSize)) {
1645 case IsTupleLike::Error:
1646 DD->setInvalidDecl();
1647 return;
1648
1649 case IsTupleLike::TupleLike:
1650 if (checkTupleLikeDecomposition(S&: *this, Bindings, Src: DD, DecompType, NumElems: 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(Loc: DD->getLocation(), DiagID: 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(S&: *this, Bindings, Src: DD, DecompType, OrigRD: RD))
1672 DD->setInvalidDecl();
1673}
1674
1675UnsignedOrNone Sema::GetDecompositionElementCount(QualType T,
1676 SourceLocation Loc) {
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(T: Unqual, Qs: 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 unsigned TupleSize;
1693 switch (isTupleLike(S&: *this, Loc, T, OutSize&: TupleSize)) {
1694 case IsTupleLike::Error:
1695 return std::nullopt;
1696 case IsTupleLike::TupleLike:
1697 return TupleSize;
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, DiagID: diag::err_incomplete_type))
1707 return std::nullopt;
1708
1709 CXXCastPath BasePath;
1710 DeclAccessPair BasePair =
1711 findDecomposableBaseClass(S&: *this, Loc, RD: OrigRD, BasePath);
1712 const auto *RD = cast_or_null<CXXRecordDecl>(Val: BasePair.getDecl());
1713 if (!RD)
1714 return std::nullopt;
1715
1716 unsigned NumFields = llvm::count_if(
1717 Range: RD->fields(), P: [](FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1718
1719 if (CheckMemberDecompositionFields(S&: *this, Loc, OrigRD, DecompType: T, BasePair))
1720 return std::nullopt;
1721
1722 return NumFields;
1723}
1724
1725void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) {
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.
1755 if (CheckEquivalentExceptionSpec(
1756 Old: OldType->getAs<FunctionProtoType>(), OldLoc: Old->getLocation(),
1757 New: NewType->getAs<FunctionProtoType>(), NewLoc: 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].
1765void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
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.
1769 if (FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
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(i: 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(i: ParamIdx);
1792 if (Param->hasDefaultArg() || Param->isParameterPack() ||
1793 (CurrentInstantiationScope &&
1794 CurrentInstantiationScope->isLocalPackExpansion(D: Param)))
1795 continue;
1796 if (Param->isInvalidDecl())
1797 /* We already complained about this parameter. */;
1798 else if (Param->getIdentifier())
1799 Diag(Loc: Param->getLocation(), DiagID: diag::err_param_default_argument_missing_name)
1800 << Param->getIdentifier();
1801 else
1802 Diag(Loc: Param->getLocation(), DiagID: 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>
1810static bool CheckLiteralType(Sema &SemaRef, Sema::CheckConstexprKind Kind,
1811 SourceLocation Loc, QualType T, unsigned DiagID,
1812 Ts &&...DiagArgs) {
1813 if (T->isDependentType())
1814 return false;
1815
1816 switch (Kind) {
1817 case Sema::CheckConstexprKind::Diagnose:
1818 return SemaRef.RequireLiteralType(Loc, T, DiagID,
1819 std::forward<Ts>(DiagArgs)...);
1820
1821 case Sema::CheckConstexprKind::CheckValid:
1822 return !T->isLiteralType(Ctx: SemaRef.Context);
1823 }
1824
1825 llvm_unreachable("unknown CheckConstexprKind");
1826}
1827
1828/// Determine whether a destructor cannot be constexpr due to
1829static bool CheckConstexprDestructorSubobjects(Sema &SemaRef,
1830 const CXXDestructorDecl *DD,
1831 Sema::CheckConstexprKind Kind) {
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 =
1836 T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1837 if (!RD || RD->hasConstexprDestructor())
1838 return true;
1839
1840 if (Kind == Sema::CheckConstexprKind::Diagnose) {
1841 SemaRef.Diag(Loc: DD->getLocation(), DiagID: diag::err_constexpr_dtor_subobject)
1842 << static_cast<int>(DD->getConstexprKind()) << !FD
1843 << (FD ? FD->getDeclName() : DeclarationName()) << T;
1844 SemaRef.Diag(Loc, DiagID: 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.
1862static bool CheckConstexprParameterTypes(Sema &SemaRef,
1863 const FunctionDecl *FD,
1864 Sema::CheckConstexprKind Kind) {
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(i: ArgIndex);
1873 assert(PD && "null in a parameter list");
1874 SourceLocation ParamLoc = PD->getLocation();
1875 if (CheckLiteralType(SemaRef, Kind, Loc: ParamLoc, T: *i,
1876 DiagID: diag::err_constexpr_non_literal_param, DiagArgs: ArgIndex + 1,
1877 DiagArgs: PD->getSourceRange(), DiagArgs: isa<CXXConstructorDecl>(Val: FD),
1878 DiagArgs: 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.
1886static bool CheckConstexprReturnType(Sema &SemaRef, const FunctionDecl *FD,
1887 Sema::CheckConstexprKind Kind) {
1888 assert(!SemaRef.getLangOpts().CPlusPlus23 &&
1889 "this check is obsolete for C++23");
1890 if (CheckLiteralType(SemaRef, Kind, Loc: FD->getLocation(), T: FD->getReturnType(),
1891 DiagID: diag::err_constexpr_non_literal_return,
1892 DiagArgs: 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.
1902static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) {
1903 switch (Tag) {
1904 case TagTypeKind::Struct:
1905 return 0;
1906 case TagTypeKind::Interface:
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,
1916 Sema::CheckConstexprKind Kind);
1917static bool CheckConstexprMissingReturn(Sema &SemaRef, const FunctionDecl *Dcl);
1918
1919bool Sema::CheckConstexprFunctionDefinition(const FunctionDecl *NewFD,
1920 CheckConstexprKind Kind) {
1921 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: 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()) {
1932 if (Kind == CheckConstexprKind::CheckValid)
1933 return false;
1934
1935 Diag(Loc: NewFD->getLocation(), DiagID: diag::err_constexpr_virtual_base)
1936 << isa<CXXConstructorDecl>(Val: NewFD)
1937 << getRecordDiagFromTagKind(Tag: RD->getTagKind()) << RD->getNumVBases();
1938 for (const auto &I : RD->vbases())
1939 Diag(Loc: I.getBeginLoc(), DiagID: diag::note_constexpr_virtual_base_here)
1940 << I.getSourceRange();
1941 return false;
1942 }
1943 }
1944
1945 if (!isa<CXXConstructorDecl>(Val: 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>(Val: NewFD);
1951 if (Method && Method->isVirtual()) {
1952 if (getLangOpts().CPlusPlus20) {
1953 if (Kind == CheckConstexprKind::Diagnose)
1954 Diag(Loc: Method->getLocation(), DiagID: diag::warn_cxx17_compat_constexpr_virtual);
1955 } else {
1956 if (Kind == CheckConstexprKind::CheckValid)
1957 return false;
1958
1959 Method = Method->getCanonicalDecl();
1960 Diag(Loc: Method->getLocation(), DiagID: 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(Loc: WrittenVirtual->getLocation(),
1969 DiagID: 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(SemaRef&: *this, FD: NewFD, Kind))
1977 return false;
1978 }
1979
1980 if (auto *Dtor = dyn_cast<CXXDestructorDecl>(Val: 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()) {
1986 if (Kind == CheckConstexprKind::CheckValid)
1987 return false;
1988 if (!CheckConstexprDestructorSubobjects(SemaRef&: *this, DD: 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(SemaRef&: *this, FD: 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(SemaRef&: *this, Dcl: 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.
2009static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
2010 DeclStmt *DS, SourceLocation &Cxx1yLoc,
2011 Sema::CheckConstexprKind Kind) {
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>(Val: DclIt);
2035 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
2036 // Don't allow variably-modified types in constexpr functions.
2037 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2038 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
2039 SemaRef.Diag(Loc: TL.getBeginLoc(), DiagID: diag::err_constexpr_vla)
2040 << TL.getSourceRange() << TL.getType()
2041 << isa<CXXConstructorDecl>(Val: 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>(Val: DclIt)->isThisDeclarationADefinition()) {
2052 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2053 SemaRef.DiagCompat(Loc: DS->getBeginLoc(),
2054 CompatDiagId: diag_compat::constexpr_type_definition)
2055 << isa<CXXConstructorDecl>(Val: 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>(Val: DclIt);
2076 if (VD->isThisDeclarationADefinition()) {
2077 if (VD->isStaticLocal()) {
2078 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2079 SemaRef.DiagCompat(Loc: VD->getLocation(),
2080 CompatDiagId: diag_compat::constexpr_static_var)
2081 << isa<CXXConstructorDecl>(Val: 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, Loc: VD->getLocation(), T: VD->getType(),
2089 DiagID: diag::warn_cxx20_compat_constexpr_var,
2090 DiagArgs: isa<CXXConstructorDecl>(Val: Dcl));
2091 } else if (CheckLiteralType(
2092 SemaRef, Kind, Loc: VD->getLocation(), T: VD->getType(),
2093 DiagID: diag::err_constexpr_local_var_non_literal_type,
2094 DiagArgs: isa<CXXConstructorDecl>(Val: Dcl))) {
2095 return false;
2096 }
2097 if (!VD->getType()->isDependentType() &&
2098 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
2099 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2100 SemaRef.DiagCompat(Loc: VD->getLocation(),
2101 CompatDiagId: diag_compat::constexpr_local_var_no_init)
2102 << isa<CXXConstructorDecl>(Val: Dcl);
2103 } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2104 return false;
2105 }
2106 continue;
2107 }
2108 }
2109 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2110 SemaRef.DiagCompat(Loc: VD->getLocation(), CompatDiagId: diag_compat::constexpr_local_var)
2111 << isa<CXXConstructorDecl>(Val: 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:
2127 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2128 SemaRef.Diag(Loc: DS->getBeginLoc(), DiagID: diag::err_constexpr_body_invalid_stmt)
2129 << isa<CXXConstructorDecl>(Val: 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.
2151static bool CheckConstexprCtorInitializer(Sema &SemaRef,
2152 const FunctionDecl *Dcl,
2153 FieldDecl *Field,
2154 llvm::SmallPtrSet<Decl *, 16> &Inits,
2155 bool &Diagnosed,
2156 Sema::CheckConstexprKind Kind) {
2157 // In C++20 onwards, there's nothing to check for validity.
2158 if (Kind == Sema::CheckConstexprKind::CheckValid &&
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(Ptr: Field)) {
2178 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2179 if (!Diagnosed) {
2180 SemaRef.DiagCompat(Loc: Dcl->getLocation(),
2181 CompatDiagId: diag_compat::constexpr_ctor_missing_init);
2182 Diagnosed = true;
2183 }
2184 SemaRef.Diag(Loc: Field->getLocation(),
2185 DiagID: 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(Ptr: I))
2195 if (!CheckConstexprCtorInitializer(SemaRef, Dcl, Field: 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
2205CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
2206 SmallVectorImpl<SourceLocation> &ReturnStmts,
2207 SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc,
2208 SourceLocation &Cxx2bLoc,
2209 Sema::CheckConstexprKind Kind) {
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, DS: cast<DeclStmt>(Val: S), Cxx1yLoc, Kind))
2223 return false;
2224 return true;
2225
2226 case Stmt::ReturnStmtClass:
2227 // - and exactly one return statement;
2228 if (isa<CXXConstructorDecl>(Val: 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(Elt: 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.
2241 return CheckConstexprFunctionStmt(
2242 SemaRef, Dcl, S: cast<AttributedStmt>(Val: 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>(Val: S);
2251 for (auto *BodyIt : CompStmt->body()) {
2252 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, S: 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>(Val: S);
2265 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, S: If->getThen(), ReturnStmts,
2266 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2267 return false;
2268 if (If->getElse() &&
2269 !CheckConstexprFunctionStmt(SemaRef, Dcl, S: 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, S: 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, S: 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, S: 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, S: 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).
2339 if (!CheckConstexprFunctionStmt(
2340 SemaRef, Dcl, S: cast<CXXCatchStmt>(Val: S)->getHandlerBlock(), ReturnStmts,
2341 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2342 return false;
2343 return true;
2344
2345 default:
2346 if (!isa<Expr>(Val: S))
2347 break;
2348
2349 // C++1y allows expression-statements.
2350 if (!Cxx1yLoc.isValid())
2351 Cxx1yLoc = S->getBeginLoc();
2352 return true;
2353 }
2354
2355 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2356 SemaRef.Diag(Loc: S->getBeginLoc(), DiagID: diag::err_constexpr_body_invalid_stmt)
2357 << isa<CXXConstructorDecl>(Val: 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.
2367static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
2368 Stmt *Body,
2369 Sema::CheckConstexprKind Kind) {
2370 SmallVector<SourceLocation, 4> ReturnStmts;
2371
2372 if (isa<CXXTryStmt>(Val: 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) {
2386 case Sema::CheckConstexprKind::CheckValid:
2387 if (!SemaRef.getLangOpts().CPlusPlus20)
2388 return false;
2389 break;
2390
2391 case Sema::CheckConstexprKind::Diagnose:
2392 SemaRef.DiagCompat(Loc: Body->getBeginLoc(),
2393 CompatDiagId: diag_compat::constexpr_function_try_block)
2394 << isa<CXXConstructorDecl>(Val: 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, S: SubStmt, ReturnStmts,
2408 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2409 return false;
2410 }
2411
2412 if (Kind == Sema::CheckConstexprKind::CheckValid) {
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(Loc: Cxx2bLoc, CompatDiagId: diag_compat::cxx23_constexpr_body_invalid_stmt)
2421 << isa<CXXConstructorDecl>(Val: Dcl);
2422 } else if (Cxx2aLoc.isValid()) {
2423 SemaRef.DiagCompat(Loc: Cxx2aLoc, CompatDiagId: diag_compat::cxx20_constexpr_body_invalid_stmt)
2424 << isa<CXXConstructorDecl>(Val: Dcl);
2425 } else if (Cxx1yLoc.isValid()) {
2426 SemaRef.DiagCompat(Loc: Cxx1yLoc, CompatDiagId: diag_compat::cxx14_constexpr_body_invalid_stmt)
2427 << isa<CXXConstructorDecl>(Val: Dcl);
2428 }
2429
2430 if (const CXXConstructorDecl *Constructor
2431 = dyn_cast<CXXConstructorDecl>(Val: 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()) {
2442 if (Kind == Sema::CheckConstexprKind::Diagnose) {
2443 SemaRef.DiagCompat(Loc: Dcl->getLocation(),
2444 CompatDiagId: 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;
2457 for (CXXRecordDecl::field_iterator I = RD->field_begin(),
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.
2473 llvm::SmallPtrSet<Decl *, 16> Inits;
2474 for (const auto *I: Constructor->inits()) {
2475 if (FieldDecl *FD = I->getMember())
2476 Inits.insert(Ptr: FD);
2477 else if (IndirectFieldDecl *ID = I->getIndirectMember())
2478 Inits.insert(I: ID->chain_begin(), E: ID->chain_end());
2479 }
2480
2481 bool Diagnosed = false;
2482 for (auto *I : RD->fields())
2483 if (!CheckConstexprCtorInitializer(SemaRef, Dcl, Field: I, Inits, Diagnosed,
2484 Kind))
2485 return false;
2486 }
2487 }
2488 } else {
2489 if (ReturnStmts.empty()) {
2490 switch (Kind) {
2491 case Sema::CheckConstexprKind::Diagnose:
2492 if (!CheckConstexprMissingReturn(SemaRef, Dcl))
2493 return false;
2494 break;
2495
2496 case Sema::CheckConstexprKind::CheckValid:
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) {
2506 case Sema::CheckConstexprKind::Diagnose:
2507 SemaRef.DiagCompat(Loc: ReturnStmts.back(),
2508 CompatDiagId: diag_compat::constexpr_body_multiple_return);
2509 for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2510 SemaRef.Diag(Loc: ReturnStmts[I],
2511 DiagID: diag::note_constexpr_body_previous_return);
2512 break;
2513
2514 case Sema::CheckConstexprKind::CheckValid:
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 ||
2540 SemaRef.getSourceManager().isInSystemHeader(Loc: Dcl->getLocation()) ||
2541 SemaRef.getDiagnostics().isIgnored(
2542 DiagID: diag::ext_constexpr_function_never_constant_expr, Loc: Dcl->getLocation());
2543 SmallVector<PartialDiagnosticAt, 8> Diags;
2544 if (Kind == Sema::CheckConstexprKind::Diagnose && !SkipCheck &&
2545 !Expr::isPotentialConstantExpr(FD: Dcl, Diags)) {
2546 SemaRef.Diag(Loc: Dcl->getLocation(),
2547 DiagID: diag::ext_constexpr_function_never_constant_expr)
2548 << isa<CXXConstructorDecl>(Val: Dcl) << Dcl->isConsteval()
2549 << Dcl->getNameInfo().getSourceRange();
2550 for (const auto &Diag : Diags)
2551 SemaRef.Diag(Loc: Diag.first, PD: Diag.second);
2552 // Don't return false here: we allow this for compatibility in
2553 // system headers.
2554 }
2555
2556 return true;
2557}
2558
2559static bool CheckConstexprMissingReturn(Sema &SemaRef,
2560 const FunctionDecl *Dcl) {
2561 bool IsVoidOrDependentType = Dcl->getReturnType()->isVoidType() ||
2562 Dcl->getReturnType()->isDependentType();
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(Loc: Dcl->getLocation(),
2575 DiagID: OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2576 : diag::err_constexpr_body_no_return)
2577 << Dcl->isConsteval();
2578 return OK;
2579}
2580
2581bool Sema::CheckImmediateEscalatingFunctionDefinition(
2582 FunctionDecl *FD, const sema::FunctionScopeInfo *FSI) {
2583 if (!getLangOpts().CPlusPlus20 || !FD->isImmediateEscalating())
2584 return true;
2585 FD->setBodyContainsImmediateEscalatingExpressions(
2586 FSI->FoundImmediateEscalatingExpression);
2587 if (FSI->FoundImmediateEscalatingExpression) {
2588 auto it = UndefinedButUsed.find(Key: FD->getCanonicalDecl());
2589 if (it != UndefinedButUsed.end()) {
2590 Diag(Loc: it->second, DiagID: diag::err_immediate_function_used_before_definition)
2591 << it->first;
2592 Diag(Loc: FD->getLocation(), DiagID: diag::note_defined_here) << FD;
2593 if (FD->isImmediateFunction() && !FD->isConsteval())
2594 DiagnoseImmediateEscalatingReason(FD);
2595 return false;
2596 }
2597 }
2598 return true;
2599}
2600
2601void Sema::DiagnoseImmediateEscalatingReason(FunctionDecl *FD) {
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>(Val: FD)) {
2616 ShouldVisitImplicitCode = true;
2617 ShouldVisitLambdaBody = false;
2618 }
2619
2620 void Diag(const Expr *E, const FunctionDecl *Fn, bool IsCall) {
2621 SourceLocation Loc = E->getBeginLoc();
2622 SourceRange Range = E->getSourceRange();
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, DiagID: diag::note_immediate_function_reason)
2632 << ImmediateFn << Fn << Fn->isConsteval() << IsCall
2633 << isa<CXXConstructorDecl>(Val: 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>(Val: E->getCallee()->IgnoreImplicit());
2641 DR && DR->isImmediateEscalating()) {
2642 Diag(E, Fn: E->getDirectCallee(), /*IsCall=*/true);
2643 return false;
2644 }
2645
2646 for (Expr *A : E->arguments())
2647 if (!TraverseStmt(S: A))
2648 return false;
2649
2650 return true;
2651 }
2652
2653 bool VisitDeclRefExpr(DeclRefExpr *E) override {
2654 if (const auto *ReferencedFn = dyn_cast<FunctionDecl>(Val: E->getDecl());
2655 ReferencedFn && E->isImmediateEscalating()) {
2656 Diag(E, Fn: 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, Fn: D, /*IsCall=*/true);
2667 return false;
2668 }
2669 return true;
2670 }
2671
2672 bool TraverseConstructorInitializer(CXXCtorInitializer *Init) override {
2673 llvm::SaveAndRestore RAII(CurrentInit, Init);
2674 return DynamicRecursiveASTVisitor::TraverseConstructorInitializer(Init);
2675 }
2676
2677 bool TraverseCXXConstructorDecl(CXXConstructorDecl *Ctr) override {
2678 llvm::SaveAndRestore RAII(CurrentConstructor, Ctr);
2679 return DynamicRecursiveASTVisitor::TraverseCXXConstructorDecl(D: 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(D: FD);
2689}
2690
2691CXXRecordDecl *Sema::getCurrentClass(Scope *, const CXXScopeSpec *SS) {
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: *SS, EnteringContext: true);
2699 return dyn_cast_or_null<CXXRecordDecl>(Val: DC);
2700 }
2701
2702 return dyn_cast_or_null<CXXRecordDecl>(Val: CurContext);
2703}
2704
2705bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *S,
2706 const CXXScopeSpec *SS) {
2707 CXXRecordDecl *CurDecl = getCurrentClass(S, SS);
2708 return CurDecl && &II == CurDecl->getIdentifier();
2709}
2710
2711bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) {
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: *SS, EnteringContext: true);
2720 CurDecl = dyn_cast_or_null<CXXRecordDecl>(Val: DC);
2721 } else
2722 CurDecl = dyn_cast_or_null<CXXRecordDecl>(Val: CurContext);
2723
2724 if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
2725 3 * II->getName().edit_distance(Other: CurDecl->getIdentifier()->getName())
2726 < II->getLength()) {
2727 II = CurDecl->getIdentifier();
2728 return true;
2729 }
2730
2731 return false;
2732}
2733
2734CXXBaseSpecifier *Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
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(Loc: EllipsisLoc, DiagID: 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>(Val: computeDeclContext(T: 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(Loc: BaseLoc, DiagID: diag::err_union_as_base_class) << SpecifierRange;
2763 return nullptr;
2764 }
2765
2766 if (BaseType.hasQualifiers()) {
2767 std::string Quals =
2768 BaseType.getQualifiers().getAsString(Policy: Context.getPrintingPolicy());
2769 Diag(Loc: BaseLoc, DiagID: diag::warn_qual_base_type)
2770 << Quals << llvm::count(Range&: Quals, Element: ' ') + 1 << BaseType;
2771 Diag(Loc: BaseLoc, DiagID: diag::note_base_class_specified_here) << BaseType;
2772 }
2773
2774 // For the MS ABI, propagate DLL attributes to base class templates.
2775 if (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
2776 Context.getTargetInfo().getTriple().isPS()) {
2777 if (Attr *ClassAttr = getDLLAttr(D: Class)) {
2778 if (auto *BaseSpec =
2779 dyn_cast<ClassTemplateSpecializationDecl>(Val: BaseDecl)) {
2780 propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplateSpec: BaseSpec,
2781 BaseLoc);
2782 }
2783 }
2784 }
2785
2786 if (RequireCompleteType(Loc: BaseLoc, T: BaseType, DiagID: diag::err_incomplete_base_class,
2787 Args: 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(Loc: Class->getLocation(), DiagID: diag::err_mismatched_code_seg_base);
2804 Diag(Loc: BaseDecl->getLocation(), DiagID: 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(Loc: BaseLoc, DiagID: 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(Loc: BaseLoc, DiagID: diag::err_class_marked_final_used_as_base)
2826 << BaseDecl->getDeclName() << FA->isSpelledAsSealed();
2827 Diag(Loc: BaseDecl->getLocation(), DiagID: 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(Loc: BaseLoc, DiagID: 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
2861BaseResult Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
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(Decl&: classdecl);
2870 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(Val: 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)
2883 DiagnoseUnknownAttribute(AL);
2884 else
2885 Diag(Loc: AL.getLoc(), DiagID: diag::err_base_specifier_attribute)
2886 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2887 }
2888
2889 TypeSourceInfo *TInfo = nullptr;
2890 GetTypeFromParser(Ty: basetype, TInfo: &TInfo);
2891
2892 if (EllipsisLoc.isInvalid() &&
2893 DiagnoseUnexpandedParameterPack(Loc: SpecifierRange.getBegin(), T: TInfo,
2894 UPPC: UPPC_BaseType))
2895 return true;
2896
2897 // C++ [class.union.general]p4:
2898 // [...] A union shall not have base classes.
2899 if (Class->isUnion()) {
2900 Diag(Loc: Class->getLocation(), DiagID: 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.
2916typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet;
2917
2918/// Recursively add the bases of Type. Don't add Type itself.
2919static void
2920NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set,
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(T: BaseSpec.getType())
2929 .getUnqualifiedType();
2930 if (Set.insert(Ptr: Base).second)
2931 // If we've not already seen it, recurse.
2932 NoteIndirectBases(Context, Set, Type: Base);
2933 }
2934 }
2935}
2936
2937bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class,
2938 MutableArrayRef<CXXBaseSpecifier *> Bases) {
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(T: 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(Loc: Bases[idx]->getBeginLoc(), DiagID: 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(Ptr: 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, Set&: IndirectBaseTypes, Type: 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(Loc: KnownBase->getBeginLoc(), DiagID: diag::err_invalid_base_in_interface)
2991 << getRecordDiagFromTagKind(Tag: RD->getTagKind()) << RD
2992 << RD->getSourceRange();
2993 Invalid = true;
2994 }
2995 if (RD->hasAttr<WeakAttr>())
2996 Class->addAttr(A: WeakAttr::CreateImplicit(Ctx&: Context));
2997 }
2998 }
2999 }
3000
3001 // Attach the remaining base class specifiers to the derived class.
3002 Class->setBases(Bases: Bases.data(), NumBases: 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(T: BaseType)
3015 .getUnqualifiedType();
3016
3017 if (IndirectBaseTypes.count(Ptr: CanonicalBase)) {
3018 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3019 /*DetectVirtual=*/true);
3020 bool found
3021 = Class->isDerivedFrom(Base: CanonicalBase->getAsCXXRecordDecl(), Paths);
3022 assert(found);
3023 (void)found;
3024
3025 if (Paths.isAmbiguous(BaseType: CanonicalBase))
3026 Diag(Loc: Bases[idx]->getBeginLoc(), DiagID: 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(Ptr: Bases[idx]);
3036 }
3037
3038 return Invalid;
3039}
3040
3041void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
3042 MutableArrayRef<CXXBaseSpecifier *> Bases) {
3043 if (!ClassDecl || Bases.empty())
3044 return;
3045
3046 AdjustDeclIfTemplate(Decl&: ClassDecl);
3047 AttachBaseSpecifiers(Class: cast<CXXRecordDecl>(Val: ClassDecl), Bases);
3048}
3049
3050bool Sema::IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived,
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?
3065 if (!isCompleteType(Loc, T: Context.getCanonicalTagType(TD: Derived)) &&
3066 !Derived->isBeingDefined())
3067 return false;
3068
3069 return Derived->isDerivedFrom(Base, Paths);
3070}
3071
3072bool Sema::IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived,
3073 CXXRecordDecl *Base) {
3074 CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
3075 /*DetectVirtual=*/false);
3076 return IsDerivedFrom(Loc, Derived, Base, Paths);
3077}
3078
3079bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
3080 CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
3081 /*DetectVirtual=*/false);
3082 return IsDerivedFrom(Loc, Derived: Derived->getAsCXXRecordDecl(),
3083 Base: Base->getAsCXXRecordDecl(), Paths);
3084}
3085
3086bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
3087 CXXBasePaths &Paths) {
3088 return IsDerivedFrom(Loc, Derived: Derived->getAsCXXRecordDecl(),
3089 Base: Base->getAsCXXRecordDecl(), Paths);
3090}
3091
3092static void BuildBasePathArray(const CXXBasePath &Path,
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(Elt: const_cast<CXXBaseSpecifier*>(Path[I].Base));
3108}
3109
3110
3111void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
3112 CXXCastPath &BasePathArray) {
3113 assert(BasePathArray.empty() && "Base path array must be empty!");
3114 assert(Paths.isRecordingPaths() && "Must record paths!");
3115 return ::BuildBasePathArray(Path: Paths.front(), BasePathArray);
3116}
3117
3118bool
3119Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
3120 unsigned InaccessibleBaseID,
3121 unsigned AmbiguousBaseConvID,
3122 SourceLocation Loc, SourceRange Range,
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(BaseType: Context.getCanonicalType(T: 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, DiagID: 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(AccessLoc: Loc, Base, Derived, Path: *Path, DiagID: 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: *Path, BasePathArray&: *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, DiagID: AmbiguousBaseConvID)
3195 << Derived << Base << PathDisplayStr << Range << Name;
3196 }
3197 return true;
3198}
3199
3200bool
3201Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
3202 SourceLocation Loc, SourceRange Range,
3203 CXXCastPath *BasePath,
3204 bool IgnoreAccess) {
3205 return CheckDerivedToBaseConversion(
3206 Derived, Base, InaccessibleBaseID: diag::err_upcast_to_inaccessible_base,
3207 AmbiguousBaseConvID: diag::err_ambiguous_derived_to_base_conv, Loc, Range, Name: DeclarationName(),
3208 BasePath, IgnoreAccess);
3209}
3210
3211std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
3212 std::string PathDisplayStr;
3213 std::set<unsigned> DisplayedPaths;
3214 for (const CXXBasePath &Path : Paths) {
3215 if (DisplayedPaths.insert(x: Path.back().SubobjectNumber).second) {
3216 // We haven't displayed a path to this particular base
3217 // class subobject yet.
3218 PathDisplayStr += "\n ";
3219 PathDisplayStr += QualType(Context.getCanonicalTagType(TD: Paths.getOrigin()))
3220 .getAsString();
3221 for (const CXXBasePathElement &Element : Path)
3222 PathDisplayStr += " -> " + Element.Base->getType().getAsString();
3223 }
3224 }
3225
3226 return PathDisplayStr;
3227}
3228
3229//===----------------------------------------------------------------------===//
3230// C++ class member Handling
3231//===----------------------------------------------------------------------===//
3232
3233bool Sema::ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,
3234 SourceLocation ColonLoc,
3235 const ParsedAttributesView &Attrs) {
3236 assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
3237 AccessSpecDecl *ASDecl = AccessSpecDecl::Create(C&: Context, AS: Access, DC: CurContext,
3238 ASLoc, ColonLoc);
3239 CurContext->addHiddenDecl(D: ASDecl);
3240 return ProcessAccessDeclAttributeList(ASDecl, AttrList: Attrs);
3241}
3242
3243void Sema::CheckOverrideControl(NamedDecl *D) {
3244 if (D->isInvalidDecl())
3245 return;
3246
3247 // We only care about "override" and "final" declarations.
3248 if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
3249 return;
3250
3251 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: D);
3252
3253 // We can't check dependent instance methods.
3254 if (MD && MD->isInstance() &&
3255 (MD->getParent()->hasAnyDependentBases() ||
3256 MD->getType()->isDependentType()))
3257 return;
3258
3259 if (MD && !MD->isVirtual()) {
3260 // If we have a non-virtual method, check if it hides a virtual method.
3261 // (In that case, it's most likely the method has the wrong type.)
3262 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
3263 FindHiddenVirtualMethods(MD, OverloadedMethods);
3264
3265 if (!OverloadedMethods.empty()) {
3266 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3267 Diag(Loc: OA->getLocation(),
3268 DiagID: diag::override_keyword_hides_virtual_member_function)
3269 << "override" << (OverloadedMethods.size() > 1);
3270 } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3271 Diag(Loc: FA->getLocation(),
3272 DiagID: diag::override_keyword_hides_virtual_member_function)
3273 << (FA->isSpelledAsSealed() ? "sealed" : "final")
3274 << (OverloadedMethods.size() > 1);
3275 }
3276 NoteHiddenVirtualMethods(MD, OverloadedMethods);
3277 MD->setInvalidDecl();
3278 return;
3279 }
3280 // Fall through into the general case diagnostic.
3281 // FIXME: We might want to attempt typo correction here.
3282 }
3283
3284 if (!MD || !MD->isVirtual()) {
3285 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3286 Diag(Loc: OA->getLocation(),
3287 DiagID: diag::override_keyword_only_allowed_on_virtual_member_functions)
3288 << "override" << FixItHint::CreateRemoval(RemoveRange: OA->getLocation());
3289 D->dropAttr<OverrideAttr>();
3290 }
3291 if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3292 Diag(Loc: FA->getLocation(),
3293 DiagID: diag::override_keyword_only_allowed_on_virtual_member_functions)
3294 << (FA->isSpelledAsSealed() ? "sealed" : "final")
3295 << FixItHint::CreateRemoval(RemoveRange: FA->getLocation());
3296 D->dropAttr<FinalAttr>();
3297 }
3298 return;
3299 }
3300
3301 // C++11 [class.virtual]p5:
3302 // If a function is marked with the virt-specifier override and
3303 // does not override a member function of a base class, the program is
3304 // ill-formed.
3305 bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
3306 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3307 Diag(Loc: MD->getLocation(), DiagID: diag::err_function_marked_override_not_overriding)
3308 << MD->getDeclName();
3309}
3310
3311void Sema::DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent) {
3312 if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
3313 return;
3314 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: D);
3315 if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
3316 return;
3317
3318 SourceLocation Loc = MD->getLocation();
3319 SourceLocation SpellingLoc = Loc;
3320 if (getSourceManager().isMacroArgExpansion(Loc))
3321 SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).getBegin();
3322 SpellingLoc = getSourceManager().getSpellingLoc(Loc: SpellingLoc);
3323 if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(Loc: SpellingLoc))
3324 return;
3325
3326 if (MD->size_overridden_methods() > 0) {
3327 auto EmitDiag = [&](unsigned DiagInconsistent, unsigned DiagSuggest) {
3328 unsigned DiagID =
3329 Inconsistent && !Diags.isIgnored(DiagID: DiagInconsistent, Loc: MD->getLocation())
3330 ? DiagInconsistent
3331 : DiagSuggest;
3332 Diag(Loc: MD->getLocation(), DiagID) << MD->getDeclName();
3333 const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
3334 Diag(Loc: OMD->getLocation(), DiagID: diag::note_overridden_virtual_function);
3335 };
3336 if (isa<CXXDestructorDecl>(Val: MD))
3337 EmitDiag(
3338 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3339 diag::warn_suggest_destructor_marked_not_override_overriding);
3340 else
3341 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3342 diag::warn_suggest_function_marked_not_override_overriding);
3343 }
3344}
3345
3346bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
3347 const CXXMethodDecl *Old) {
3348 FinalAttr *FA = Old->getAttr<FinalAttr>();
3349 if (!FA)
3350 return false;
3351
3352 Diag(Loc: New->getLocation(), DiagID: diag::err_final_function_overridden)
3353 << New->getDeclName()
3354 << FA->isSpelledAsSealed();
3355 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function);
3356 return true;
3357}
3358
3359static bool InitializationHasSideEffects(const FieldDecl &FD) {
3360 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
3361 // FIXME: Destruction of ObjC lifetime types has side-effects.
3362 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3363 return !RD->isCompleteDefinition() ||
3364 !RD->hasTrivialDefaultConstructor() ||
3365 !RD->hasTrivialDestructor();
3366 return false;
3367}
3368
3369void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
3370 DeclarationName FieldName,
3371 const CXXRecordDecl *RD,
3372 bool DeclIsField) {
3373 if (Diags.isIgnored(DiagID: diag::warn_shadow_field, Loc))
3374 return;
3375
3376 // To record a shadowed field in a base
3377 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3378 auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
3379 CXXBasePath &Path) {
3380 const auto Base = Specifier->getType()->getAsCXXRecordDecl();
3381 // Record an ambiguous path directly
3382 if (Bases.find(x: Base) != Bases.end())
3383 return true;
3384 for (const auto Field : Base->lookup(Name: FieldName)) {
3385 if ((isa<FieldDecl>(Val: Field) || isa<IndirectFieldDecl>(Val: Field)) &&
3386 Field->getAccess() != AS_private) {
3387 assert(Field->getAccess() != AS_none);
3388 assert(Bases.find(Base) == Bases.end());
3389 Bases[Base] = Field;
3390 return true;
3391 }
3392 }
3393 return false;
3394 };
3395
3396 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3397 /*DetectVirtual=*/true);
3398 if (!RD->lookupInBases(BaseMatches: FieldShadowed, Paths))
3399 return;
3400
3401 for (const auto &P : Paths) {
3402 auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
3403 auto It = Bases.find(x: Base);
3404 // Skip duplicated bases
3405 if (It == Bases.end())
3406 continue;
3407 auto BaseField = It->second;
3408 assert(BaseField->getAccess() != AS_private);
3409 if (AS_none !=
3410 CXXRecordDecl::MergeAccess(PathAccess: P.Access, DeclAccess: BaseField->getAccess())) {
3411 Diag(Loc, DiagID: diag::warn_shadow_field)
3412 << FieldName << RD << Base << DeclIsField;
3413 Diag(Loc: BaseField->getLocation(), DiagID: diag::note_shadow_field);
3414 Bases.erase(position: It);
3415 }
3416 }
3417}
3418
3419template <typename AttrType>
3420inline static bool HasAttribute(const QualType &T) {
3421 if (const TagDecl *TD = T->getAsTagDecl())
3422 return TD->hasAttr<AttrType>();
3423 if (const TypedefType *TDT = T->getAs<TypedefType>())
3424 return TDT->getDecl()->hasAttr<AttrType>();
3425 return false;
3426}
3427
3428static bool IsUnusedPrivateField(const FieldDecl *FD) {
3429 if (FD->getAccess() == AS_private && FD->getDeclName()) {
3430 QualType FieldType = FD->getType();
3431 if (HasAttribute<WarnUnusedAttr>(T: FieldType))
3432 return true;
3433
3434 return !FD->isImplicit() && !FD->hasAttr<UnusedAttr>() &&
3435 !FD->getParent()->isDependentContext() &&
3436 !HasAttribute<UnusedAttr>(T: FieldType) &&
3437 !InitializationHasSideEffects(FD: *FD);
3438 }
3439 return false;
3440}
3441
3442NamedDecl *
3443Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
3444 MultiTemplateParamsArg TemplateParameterLists,
3445 Expr *BitWidth, const VirtSpecifiers &VS,
3446 InClassInitStyle InitStyle) {
3447 const DeclSpec &DS = D.getDeclSpec();
3448 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
3449 DeclarationName Name = NameInfo.getName();
3450 SourceLocation Loc = NameInfo.getLoc();
3451
3452 // For anonymous bitfields, the location should point to the type.
3453 if (Loc.isInvalid())
3454 Loc = D.getBeginLoc();
3455
3456 assert(isa<CXXRecordDecl>(CurContext));
3457 assert(!DS.isFriendSpecified());
3458
3459 bool isFunc = D.isDeclarationOfFunction();
3460 const ParsedAttr *MSPropertyAttr =
3461 D.getDeclSpec().getAttributes().getMSPropertyAttr();
3462
3463 if (cast<CXXRecordDecl>(Val: CurContext)->isInterface()) {
3464 // The Microsoft extension __interface only permits public member functions
3465 // and prohibits constructors, destructors, operators, non-public member
3466 // functions, static methods and data members.
3467 unsigned InvalidDecl;
3468 bool ShowDeclName = true;
3469 if (!isFunc &&
3470 (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
3471 InvalidDecl = 0;
3472 else if (!isFunc)
3473 InvalidDecl = 1;
3474 else if (AS != AS_public)
3475 InvalidDecl = 2;
3476 else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
3477 InvalidDecl = 3;
3478 else switch (Name.getNameKind()) {
3479 case DeclarationName::CXXConstructorName:
3480 InvalidDecl = 4;
3481 ShowDeclName = false;
3482 break;
3483
3484 case DeclarationName::CXXDestructorName:
3485 InvalidDecl = 5;
3486 ShowDeclName = false;
3487 break;
3488
3489 case DeclarationName::CXXOperatorName:
3490 case DeclarationName::CXXConversionFunctionName:
3491 InvalidDecl = 6;
3492 break;
3493
3494 default:
3495 InvalidDecl = 0;
3496 break;
3497 }
3498
3499 if (InvalidDecl) {
3500 if (ShowDeclName)
3501 Diag(Loc, DiagID: diag::err_invalid_member_in_interface)
3502 << (InvalidDecl-1) << Name;
3503 else
3504 Diag(Loc, DiagID: diag::err_invalid_member_in_interface)
3505 << (InvalidDecl-1) << "";
3506 return nullptr;
3507 }
3508 }
3509
3510 // C++ 9.2p6: A member shall not be declared to have automatic storage
3511 // duration (auto, register) or with the extern storage-class-specifier.
3512 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
3513 // data members and cannot be applied to names declared const or static,
3514 // and cannot be applied to reference members.
3515 switch (DS.getStorageClassSpec()) {
3516 case DeclSpec::SCS_unspecified:
3517 case DeclSpec::SCS_typedef:
3518 case DeclSpec::SCS_static:
3519 break;
3520 case DeclSpec::SCS_mutable:
3521 if (isFunc) {
3522 Diag(Loc: DS.getStorageClassSpecLoc(), DiagID: diag::err_mutable_function);
3523
3524 // FIXME: It would be nicer if the keyword was ignored only for this
3525 // declarator. Otherwise we could get follow-up errors.
3526 D.getMutableDeclSpec().ClearStorageClassSpecs();
3527 }
3528 break;
3529 default:
3530 Diag(Loc: DS.getStorageClassSpecLoc(),
3531 DiagID: diag::err_storageclass_invalid_for_member);
3532 D.getMutableDeclSpec().ClearStorageClassSpecs();
3533 break;
3534 }
3535
3536 bool isInstField = (DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
3537 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
3538 !isFunc && TemplateParameterLists.empty();
3539
3540 if (DS.hasConstexprSpecifier() && isInstField) {
3541 SemaDiagnosticBuilder B =
3542 Diag(Loc: DS.getConstexprSpecLoc(), DiagID: diag::err_invalid_constexpr_member);
3543 SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
3544 if (InitStyle == ICIS_NoInit) {
3545 B << 0 << 0;
3546 if (D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const)
3547 B << FixItHint::CreateRemoval(RemoveRange: ConstexprLoc);
3548 else {
3549 B << FixItHint::CreateReplacement(RemoveRange: ConstexprLoc, Code: "const");
3550 D.getMutableDeclSpec().ClearConstexprSpec();
3551 const char *PrevSpec;
3552 unsigned DiagID;
3553 bool Failed = D.getMutableDeclSpec().SetTypeQual(
3554 T: DeclSpec::TQ_const, Loc: ConstexprLoc, PrevSpec, DiagID, Lang: getLangOpts());
3555 (void)Failed;
3556 assert(!Failed && "Making a constexpr member const shouldn't fail");
3557 }
3558 } else {
3559 B << 1;
3560 const char *PrevSpec;
3561 unsigned DiagID;
3562 if (D.getMutableDeclSpec().SetStorageClassSpec(
3563 S&: *this, SC: DeclSpec::SCS_static, Loc: ConstexprLoc, PrevSpec, DiagID,
3564 Policy: Context.getPrintingPolicy())) {
3565 assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
3566 "This is the only DeclSpec that should fail to be applied");
3567 B << 1;
3568 } else {
3569 B << 0 << FixItHint::CreateInsertion(InsertionLoc: ConstexprLoc, Code: "static ");
3570 isInstField = false;
3571 }
3572 }
3573 }
3574
3575 NamedDecl *Member;
3576 if (isInstField) {
3577 CXXScopeSpec &SS = D.getCXXScopeSpec();
3578
3579 // Data members must have identifiers for names.
3580 if (!Name.isIdentifier()) {
3581 Diag(Loc, DiagID: diag::err_bad_variable_name)
3582 << Name;
3583 return nullptr;
3584 }
3585
3586 IdentifierInfo *II = Name.getAsIdentifierInfo();
3587 if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
3588 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_member_with_template_arguments)
3589 << II
3590 << SourceRange(D.getName().TemplateId->LAngleLoc,
3591 D.getName().TemplateId->RAngleLoc)
3592 << D.getName().TemplateId->LAngleLoc;
3593 D.SetIdentifier(Id: II, IdLoc: Loc);
3594 }
3595
3596 if (SS.isSet() && !SS.isInvalid()) {
3597 // The user provided a superfluous scope specifier inside a class
3598 // definition:
3599 //
3600 // class X {
3601 // int X::member;
3602 // };
3603 if (DeclContext *DC = computeDeclContext(SS, EnteringContext: false)) {
3604 TemplateIdAnnotation *TemplateId =
3605 D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
3606 ? D.getName().TemplateId
3607 : nullptr;
3608 diagnoseQualifiedDeclaration(SS, DC, Name, Loc: D.getIdentifierLoc(),
3609 TemplateId,
3610 /*IsMemberSpecialization=*/false);
3611 } else {
3612 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_member_qualification)
3613 << Name << SS.getRange();
3614 }
3615 SS.clear();
3616 }
3617
3618 if (MSPropertyAttr) {
3619 Member = HandleMSProperty(S, TagD: cast<CXXRecordDecl>(Val: CurContext), DeclStart: Loc, D,
3620 BitfieldWidth: BitWidth, InitStyle, AS, MSPropertyAttr: *MSPropertyAttr);
3621 if (!Member)
3622 return nullptr;
3623 isInstField = false;
3624 } else {
3625 Member = HandleField(S, TagD: cast<CXXRecordDecl>(Val: CurContext), DeclStart: Loc, D,
3626 BitfieldWidth: BitWidth, InitStyle, AS);
3627 if (!Member)
3628 return nullptr;
3629 }
3630
3631 CheckShadowInheritedFields(Loc, FieldName: Name, RD: cast<CXXRecordDecl>(Val: CurContext));
3632 } else {
3633 Member = HandleDeclarator(S, D, TemplateParameterLists);
3634 if (!Member)
3635 return nullptr;
3636
3637 // Non-instance-fields can't have a bitfield.
3638 if (BitWidth) {
3639 if (Member->isInvalidDecl()) {
3640 // don't emit another diagnostic.
3641 } else if (isa<VarDecl>(Val: Member) || isa<VarTemplateDecl>(Val: Member)) {
3642 // C++ 9.6p3: A bit-field shall not be a static member.
3643 // "static member 'A' cannot be a bit-field"
3644 Diag(Loc, DiagID: diag::err_static_not_bitfield)
3645 << Name << BitWidth->getSourceRange();
3646 } else if (isa<TypedefDecl>(Val: Member)) {
3647 // "typedef member 'x' cannot be a bit-field"
3648 Diag(Loc, DiagID: diag::err_typedef_not_bitfield)
3649 << Name << BitWidth->getSourceRange();
3650 } else {
3651 // A function typedef ("typedef int f(); f a;").
3652 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3653 Diag(Loc, DiagID: diag::err_not_integral_type_bitfield)
3654 << Name << cast<ValueDecl>(Val: Member)->getType()
3655 << BitWidth->getSourceRange();
3656 }
3657
3658 BitWidth = nullptr;
3659 Member->setInvalidDecl();
3660 }
3661
3662 NamedDecl *NonTemplateMember = Member;
3663 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Val: Member))
3664 NonTemplateMember = FunTmpl->getTemplatedDecl();
3665 else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Val: Member))
3666 NonTemplateMember = VarTmpl->getTemplatedDecl();
3667
3668 Member->setAccess(AS);
3669
3670 // If we have declared a member function template or static data member
3671 // template, set the access of the templated declaration as well.
3672 if (NonTemplateMember != Member)
3673 NonTemplateMember->setAccess(AS);
3674
3675 // C++ [temp.deduct.guide]p3:
3676 // A deduction guide [...] for a member class template [shall be
3677 // declared] with the same access [as the template].
3678 if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(Val: NonTemplateMember)) {
3679 auto *TD = DG->getDeducedTemplate();
3680 // Access specifiers are only meaningful if both the template and the
3681 // deduction guide are from the same scope.
3682 if (AS != TD->getAccess() &&
3683 TD->getDeclContext()->getRedeclContext()->Equals(
3684 DC: DG->getDeclContext()->getRedeclContext())) {
3685 Diag(Loc: DG->getBeginLoc(), DiagID: diag::err_deduction_guide_wrong_access);
3686 Diag(Loc: TD->getBeginLoc(), DiagID: diag::note_deduction_guide_template_access)
3687 << TD->getAccess();
3688 const AccessSpecDecl *LastAccessSpec = nullptr;
3689 for (const auto *D : cast<CXXRecordDecl>(Val: CurContext)->decls()) {
3690 if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(Val: D))
3691 LastAccessSpec = AccessSpec;
3692 }
3693 assert(LastAccessSpec && "differing access with no access specifier");
3694 Diag(Loc: LastAccessSpec->getBeginLoc(), DiagID: diag::note_deduction_guide_access)
3695 << AS;
3696 }
3697 }
3698 }
3699
3700 if (VS.isOverrideSpecified())
3701 Member->addAttr(A: OverrideAttr::Create(Ctx&: Context, Range: VS.getOverrideLoc()));
3702 if (VS.isFinalSpecified())
3703 Member->addAttr(A: FinalAttr::Create(Ctx&: Context, Range: VS.getFinalLoc(),
3704 S: VS.isFinalSpelledSealed()
3705 ? FinalAttr::Keyword_sealed
3706 : FinalAttr::Keyword_final));
3707
3708 if (VS.getLastLocation().isValid()) {
3709 // Update the end location of a method that has a virt-specifiers.
3710 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Val: Member))
3711 MD->setRangeEnd(VS.getLastLocation());
3712 }
3713
3714 CheckOverrideControl(D: Member);
3715
3716 assert((Name || isInstField) && "No identifier for non-field ?");
3717
3718 if (isInstField) {
3719 FieldDecl *FD = cast<FieldDecl>(Val: Member);
3720 FieldCollector->Add(D: FD);
3721
3722 if (!Diags.isIgnored(DiagID: diag::warn_unused_private_field, Loc: FD->getLocation()) &&
3723 IsUnusedPrivateField(FD)) {
3724 // Remember all explicit private FieldDecls that have a name, no side
3725 // effects and are not part of a dependent type declaration.
3726 UnusedPrivateFields.insert(X: FD);
3727 }
3728 }
3729
3730 return Member;
3731}
3732
3733namespace {
3734 class UninitializedFieldVisitor
3735 : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
3736 Sema &S;
3737 // List of Decls to generate a warning on. Also remove Decls that become
3738 // initialized.
3739 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3740 // List of base classes of the record. Classes are removed after their
3741 // initializers.
3742 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3743 // Vector of decls to be removed from the Decl set prior to visiting the
3744 // nodes. These Decls may have been initialized in the prior initializer.
3745 llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
3746 // If non-null, add a note to the warning pointing back to the constructor.
3747 const CXXConstructorDecl *Constructor;
3748 // Variables to hold state when processing an initializer list. When
3749 // InitList is true, special case initialization of FieldDecls matching
3750 // InitListFieldDecl.
3751 bool InitList;
3752 FieldDecl *InitListFieldDecl;
3753 llvm::SmallVector<unsigned, 4> InitFieldIndex;
3754
3755 public:
3756 typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited;
3757 UninitializedFieldVisitor(Sema &S,
3758 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3759 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3760 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3761 Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
3762
3763 // Returns true if the use of ME is not an uninitialized use.
3764 bool IsInitListMemberExprInitialized(MemberExpr *ME,
3765 bool CheckReferenceOnly) {
3766 llvm::SmallVector<FieldDecl*, 4> Fields;
3767 bool ReferenceField = false;
3768 while (ME) {
3769 FieldDecl *FD = dyn_cast<FieldDecl>(Val: ME->getMemberDecl());
3770 if (!FD)
3771 return false;
3772 Fields.push_back(Elt: FD);
3773 if (FD->getType()->isReferenceType())
3774 ReferenceField = true;
3775 ME = dyn_cast<MemberExpr>(Val: ME->getBase()->IgnoreParenImpCasts());
3776 }
3777
3778 // Binding a reference to an uninitialized field is not an
3779 // uninitialized use.
3780 if (CheckReferenceOnly && !ReferenceField)
3781 return true;
3782
3783 // Discard the first field since it is the field decl that is being
3784 // initialized.
3785 auto UsedFields = llvm::drop_begin(RangeOrContainer: llvm::reverse(C&: Fields));
3786 auto UsedIter = UsedFields.begin();
3787 const auto UsedEnd = UsedFields.end();
3788
3789 for (const unsigned Orig : InitFieldIndex) {
3790 if (UsedIter == UsedEnd)
3791 break;
3792 const unsigned UsedIndex = (*UsedIter)->getFieldIndex();
3793 if (UsedIndex < Orig)
3794 return true;
3795 if (UsedIndex > Orig)
3796 break;
3797 ++UsedIter;
3798 }
3799
3800 return false;
3801 }
3802
3803 void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
3804 bool AddressOf) {
3805 if (isa<EnumConstantDecl>(Val: ME->getMemberDecl()))
3806 return;
3807
3808 // FieldME is the inner-most MemberExpr that is not an anonymous struct
3809 // or union.
3810 MemberExpr *FieldME = ME;
3811
3812 bool AllPODFields = FieldME->getType().isPODType(Context: S.Context);
3813
3814 Expr *Base = ME;
3815 while (MemberExpr *SubME =
3816 dyn_cast<MemberExpr>(Val: Base->IgnoreParenImpCasts())) {
3817
3818 if (isa<VarDecl>(Val: SubME->getMemberDecl()))
3819 return;
3820
3821 if (FieldDecl *FD = dyn_cast<FieldDecl>(Val: SubME->getMemberDecl()))
3822 if (!FD->isAnonymousStructOrUnion())
3823 FieldME = SubME;
3824
3825 if (!FieldME->getType().isPODType(Context: S.Context))
3826 AllPODFields = false;
3827
3828 Base = SubME->getBase();
3829 }
3830
3831 if (!isa<CXXThisExpr>(Val: Base->IgnoreParenImpCasts())) {
3832 Visit(S: Base);
3833 return;
3834 }
3835
3836 if (AddressOf && AllPODFields)
3837 return;
3838
3839 ValueDecl* FoundVD = FieldME->getMemberDecl();
3840
3841 if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Val: Base)) {
3842 while (isa<ImplicitCastExpr>(Val: BaseCast->getSubExpr())) {
3843 BaseCast = cast<ImplicitCastExpr>(Val: BaseCast->getSubExpr());
3844 }
3845
3846 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3847 QualType T = BaseCast->getType();
3848 if (T->isPointerType() &&
3849 BaseClasses.count(Ptr: T->getPointeeType())) {
3850 S.Diag(Loc: FieldME->getExprLoc(), DiagID: diag::warn_base_class_is_uninit)
3851 << T->getPointeeType() << FoundVD;
3852 }
3853 }
3854 }
3855
3856 if (!Decls.count(Ptr: FoundVD))
3857 return;
3858
3859 const bool IsReference = FoundVD->getType()->isReferenceType();
3860
3861 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3862 // Special checking for initializer lists.
3863 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3864 return;
3865 }
3866 } else {
3867 // Prevent double warnings on use of unbounded references.
3868 if (CheckReferenceOnly && !IsReference)
3869 return;
3870 }
3871
3872 unsigned diag = IsReference
3873 ? diag::warn_reference_field_is_uninit
3874 : diag::warn_field_is_uninit;
3875 S.Diag(Loc: FieldME->getExprLoc(), DiagID: diag) << FoundVD;
3876 if (Constructor)
3877 S.Diag(Loc: Constructor->getLocation(),
3878 DiagID: diag::note_uninit_in_this_constructor)
3879 << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
3880
3881 }
3882
3883 void HandleValue(Expr *E, bool AddressOf) {
3884 E = E->IgnoreParens();
3885
3886 if (MemberExpr *ME = dyn_cast<MemberExpr>(Val: E)) {
3887 HandleMemberExpr(ME, CheckReferenceOnly: false /*CheckReferenceOnly*/,
3888 AddressOf /*AddressOf*/);
3889 return;
3890 }
3891
3892 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(Val: E)) {
3893 Visit(S: CO->getCond());
3894 HandleValue(E: CO->getTrueExpr(), AddressOf);
3895 HandleValue(E: CO->getFalseExpr(), AddressOf);
3896 return;
3897 }
3898
3899 if (BinaryConditionalOperator *BCO =
3900 dyn_cast<BinaryConditionalOperator>(Val: E)) {
3901 Visit(S: BCO->getCond());
3902 HandleValue(E: BCO->getFalseExpr(), AddressOf);
3903 return;
3904 }
3905
3906 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Val: E)) {
3907 HandleValue(E: OVE->getSourceExpr(), AddressOf);
3908 return;
3909 }
3910
3911 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Val: E)) {
3912 switch (BO->getOpcode()) {
3913 default:
3914 break;
3915 case(BO_PtrMemD):
3916 case(BO_PtrMemI):
3917 HandleValue(E: BO->getLHS(), AddressOf);
3918 Visit(S: BO->getRHS());
3919 return;
3920 case(BO_Comma):
3921 Visit(S: BO->getLHS());
3922 HandleValue(E: BO->getRHS(), AddressOf);
3923 return;
3924 }
3925 }
3926
3927 Visit(S: E);
3928 }
3929
3930 void CheckInitListExpr(InitListExpr *ILE) {
3931 InitFieldIndex.push_back(Elt: 0);
3932 for (auto *Child : ILE->children()) {
3933 if (InitListExpr *SubList = dyn_cast<InitListExpr>(Val: Child)) {
3934 CheckInitListExpr(ILE: SubList);
3935 } else {
3936 Visit(S: Child);
3937 }
3938 ++InitFieldIndex.back();
3939 }
3940 InitFieldIndex.pop_back();
3941 }
3942
3943 void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3944 FieldDecl *Field, const Type *BaseClass) {
3945 // Remove Decls that may have been initialized in the previous
3946 // initializer.
3947 for (ValueDecl* VD : DeclsToRemove)
3948 Decls.erase(Ptr: VD);
3949 DeclsToRemove.clear();
3950
3951 Constructor = FieldConstructor;
3952 InitListExpr *ILE = dyn_cast<InitListExpr>(Val: E);
3953
3954 if (ILE && Field) {
3955 InitList = true;
3956 InitListFieldDecl = Field;
3957 InitFieldIndex.clear();
3958 CheckInitListExpr(ILE);
3959 } else {
3960 InitList = false;
3961 Visit(S: E);
3962 }
3963
3964 if (Field)
3965 Decls.erase(Ptr: Field);
3966 if (BaseClass)
3967 BaseClasses.erase(Ptr: BaseClass->getCanonicalTypeInternal());
3968 }
3969
3970 void VisitMemberExpr(MemberExpr *ME) {
3971 // All uses of unbounded reference fields will warn.
3972 HandleMemberExpr(ME, CheckReferenceOnly: true /*CheckReferenceOnly*/, AddressOf: false /*AddressOf*/);
3973 }
3974
3975 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
3976 if (E->getCastKind() == CK_LValueToRValue) {
3977 HandleValue(E: E->getSubExpr(), AddressOf: false /*AddressOf*/);
3978 return;
3979 }
3980
3981 Inherited::VisitImplicitCastExpr(S: E);
3982 }
3983
3984 void VisitCXXConstructExpr(CXXConstructExpr *E) {
3985 if (E->getConstructor()->isCopyConstructor()) {
3986 Expr *ArgExpr = E->getArg(Arg: 0);
3987 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Val: ArgExpr))
3988 if (ILE->getNumInits() == 1)
3989 ArgExpr = ILE->getInit(Init: 0);
3990 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Val: ArgExpr))
3991 if (ICE->getCastKind() == CK_NoOp)
3992 ArgExpr = ICE->getSubExpr();
3993 HandleValue(E: ArgExpr, AddressOf: false /*AddressOf*/);
3994 return;
3995 }
3996 Inherited::VisitCXXConstructExpr(S: E);
3997 }
3998
3999 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
4000 Expr *Callee = E->getCallee();
4001 if (isa<MemberExpr>(Val: Callee)) {
4002 HandleValue(E: Callee, AddressOf: false /*AddressOf*/);
4003 for (auto *Arg : E->arguments())
4004 Visit(S: Arg);
4005 return;
4006 }
4007
4008 Inherited::VisitCXXMemberCallExpr(S: E);
4009 }
4010
4011 void VisitCallExpr(CallExpr *E) {
4012 // Treat std::move as a use.
4013 if (E->isCallToStdMove()) {
4014 HandleValue(E: E->getArg(Arg: 0), /*AddressOf=*/false);
4015 return;
4016 }
4017
4018 Inherited::VisitCallExpr(CE: E);
4019 }
4020
4021 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
4022 Expr *Callee = E->getCallee();
4023
4024 if (isa<UnresolvedLookupExpr>(Val: Callee))
4025 return Inherited::VisitCXXOperatorCallExpr(S: E);
4026
4027 Visit(S: Callee);
4028 for (auto *Arg : E->arguments())
4029 HandleValue(E: Arg->IgnoreParenImpCasts(), AddressOf: false /*AddressOf*/);
4030 }
4031
4032 void VisitBinaryOperator(BinaryOperator *E) {
4033 // If a field assignment is detected, remove the field from the
4034 // uninitiailized field set.
4035 if (E->getOpcode() == BO_Assign)
4036 if (MemberExpr *ME = dyn_cast<MemberExpr>(Val: E->getLHS()))
4037 if (FieldDecl *FD = dyn_cast<FieldDecl>(Val: ME->getMemberDecl()))
4038 if (!FD->getType()->isReferenceType())
4039 DeclsToRemove.push_back(Elt: FD);
4040
4041 if (E->isCompoundAssignmentOp()) {
4042 HandleValue(E: E->getLHS(), AddressOf: false /*AddressOf*/);
4043 Visit(S: E->getRHS());
4044 return;
4045 }
4046
4047 Inherited::VisitBinaryOperator(S: E);
4048 }
4049
4050 void VisitUnaryOperator(UnaryOperator *E) {
4051 if (E->isIncrementDecrementOp()) {
4052 HandleValue(E: E->getSubExpr(), AddressOf: false /*AddressOf*/);
4053 return;
4054 }
4055 if (E->getOpcode() == UO_AddrOf) {
4056 if (MemberExpr *ME = dyn_cast<MemberExpr>(Val: E->getSubExpr())) {
4057 HandleValue(E: ME->getBase(), AddressOf: true /*AddressOf*/);
4058 return;
4059 }
4060 }
4061
4062 Inherited::VisitUnaryOperator(S: E);
4063 }
4064 };
4065
4066 // Diagnose value-uses of fields to initialize themselves, e.g.
4067 // foo(foo)
4068 // where foo is not also a parameter to the constructor.
4069 // Also diagnose across field uninitialized use such as
4070 // x(y), y(x)
4071 // TODO: implement -Wuninitialized and fold this into that framework.
4072 static void DiagnoseUninitializedFields(
4073 Sema &SemaRef, const CXXConstructorDecl *Constructor) {
4074
4075 if (SemaRef.getDiagnostics().isIgnored(DiagID: diag::warn_field_is_uninit,
4076 Loc: Constructor->getLocation())) {
4077 return;
4078 }
4079
4080 if (Constructor->isInvalidDecl())
4081 return;
4082
4083 const CXXRecordDecl *RD = Constructor->getParent();
4084
4085 if (RD->isDependentContext())
4086 return;
4087
4088 // Holds fields that are uninitialized.
4089 llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
4090
4091 // At the beginning, all fields are uninitialized.
4092 for (auto *I : RD->decls()) {
4093 if (auto *FD = dyn_cast<FieldDecl>(Val: I)) {
4094 UninitializedFields.insert(Ptr: FD);
4095 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(Val: I)) {
4096 UninitializedFields.insert(Ptr: IFD->getAnonField());
4097 }
4098 }
4099
4100 llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
4101 for (const auto &I : RD->bases())
4102 UninitializedBaseClasses.insert(Ptr: I.getType().getCanonicalType());
4103
4104 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4105 return;
4106
4107 UninitializedFieldVisitor UninitializedChecker(SemaRef,
4108 UninitializedFields,
4109 UninitializedBaseClasses);
4110
4111 for (const auto *FieldInit : Constructor->inits()) {
4112 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4113 break;
4114
4115 Expr *InitExpr = FieldInit->getInit();
4116 if (!InitExpr)
4117 continue;
4118
4119 if (CXXDefaultInitExpr *Default =
4120 dyn_cast<CXXDefaultInitExpr>(Val: InitExpr)) {
4121 InitExpr = Default->getExpr();
4122 if (!InitExpr)
4123 continue;
4124 // In class initializers will point to the constructor.
4125 UninitializedChecker.CheckInitializer(E: InitExpr, FieldConstructor: Constructor,
4126 Field: FieldInit->getAnyMember(),
4127 BaseClass: FieldInit->getBaseClass());
4128 } else {
4129 UninitializedChecker.CheckInitializer(E: InitExpr, FieldConstructor: nullptr,
4130 Field: FieldInit->getAnyMember(),
4131 BaseClass: FieldInit->getBaseClass());
4132 }
4133 }
4134 }
4135} // namespace
4136
4137void Sema::ActOnStartCXXInClassMemberInitializer() {
4138 // Create a synthetic function scope to represent the call to the constructor
4139 // that notionally surrounds a use of this initializer.
4140 PushFunctionScope();
4141}
4142
4143void Sema::ActOnStartTrailingRequiresClause(Scope *S, Declarator &D) {
4144 if (!D.isFunctionDeclarator())
4145 return;
4146 auto &FTI = D.getFunctionTypeInfo();
4147 if (!FTI.Params)
4148 return;
4149 for (auto &Param : ArrayRef<DeclaratorChunk::ParamInfo>(FTI.Params,
4150 FTI.NumParams)) {
4151 auto *ParamDecl = cast<NamedDecl>(Val: Param.Param);
4152 if (ParamDecl->getDeclName())
4153 PushOnScopeChains(D: ParamDecl, S, /*AddToContext=*/false);
4154 }
4155}
4156
4157ExprResult Sema::ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr) {
4158 return ActOnRequiresClause(ConstraintExpr);
4159}
4160
4161ExprResult Sema::ActOnRequiresClause(ExprResult ConstraintExpr) {
4162 if (ConstraintExpr.isInvalid())
4163 return ExprError();
4164
4165 if (DiagnoseUnexpandedParameterPack(E: ConstraintExpr.get(),
4166 UPPC: UPPC_RequiresClause))
4167 return ExprError();
4168
4169 return ConstraintExpr;
4170}
4171
4172ExprResult Sema::ConvertMemberDefaultInitExpression(FieldDecl *FD,
4173 Expr *InitExpr,
4174 SourceLocation InitLoc) {
4175 InitializedEntity Entity =
4176 InitializedEntity::InitializeMemberFromDefaultMemberInitializer(Member: FD);
4177 InitializationKind Kind =
4178 FD->getInClassInitStyle() == ICIS_ListInit
4179 ? InitializationKind::CreateDirectList(InitLoc: InitExpr->getBeginLoc(),
4180 LBraceLoc: InitExpr->getBeginLoc(),
4181 RBraceLoc: InitExpr->getEndLoc())
4182 : InitializationKind::CreateCopy(InitLoc: InitExpr->getBeginLoc(), EqualLoc: InitLoc);
4183 InitializationSequence Seq(*this, Entity, Kind, InitExpr);
4184 return Seq.Perform(S&: *this, Entity, Kind, Args: InitExpr);
4185}
4186
4187void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D,
4188 SourceLocation InitLoc,
4189 ExprResult InitExpr) {
4190 // Pop the notional constructor scope we created earlier.
4191 PopFunctionScopeInfo(WP: nullptr, D);
4192
4193 // Microsoft C++'s property declaration cannot have a default member
4194 // initializer.
4195 if (isa<MSPropertyDecl>(Val: D)) {
4196 D->setInvalidDecl();
4197 return;
4198 }
4199
4200 FieldDecl *FD = dyn_cast<FieldDecl>(Val: D);
4201 assert((FD && FD->getInClassInitStyle() != ICIS_NoInit) &&
4202 "must set init style when field is created");
4203
4204 if (!InitExpr.isUsable() ||
4205 DiagnoseUnexpandedParameterPack(E: InitExpr.get(), UPPC: UPPC_Initializer)) {
4206 FD->setInvalidDecl();
4207 ExprResult RecoveryInit =
4208 CreateRecoveryExpr(Begin: InitLoc, End: InitLoc, SubExprs: {}, T: FD->getType());
4209 if (RecoveryInit.isUsable())
4210 FD->setInClassInitializer(RecoveryInit.get());
4211 return;
4212 }
4213
4214 if (!FD->getType()->isDependentType() && !InitExpr.get()->isTypeDependent()) {
4215 InitExpr = ConvertMemberDefaultInitExpression(FD, InitExpr: InitExpr.get(), InitLoc);
4216 // C++11 [class.base.init]p7:
4217 // The initialization of each base and member constitutes a
4218 // full-expression.
4219 if (!InitExpr.isInvalid())
4220 InitExpr = ActOnFinishFullExpr(Expr: InitExpr.get(), /*DiscarededValue=*/DiscardedValue: false);
4221 if (InitExpr.isInvalid()) {
4222 FD->setInvalidDecl();
4223 return;
4224 }
4225 }
4226
4227 FD->setInClassInitializer(InitExpr.get());
4228}
4229
4230/// Find the direct and/or virtual base specifiers that
4231/// correspond to the given base type, for use in base initialization
4232/// within a constructor.
4233static bool FindBaseInitializer(Sema &SemaRef,
4234 CXXRecordDecl *ClassDecl,
4235 QualType BaseType,
4236 const CXXBaseSpecifier *&DirectBaseSpec,
4237 const CXXBaseSpecifier *&VirtualBaseSpec) {
4238 // First, check for a direct base class.
4239 DirectBaseSpec = nullptr;
4240 for (const auto &Base : ClassDecl->bases()) {
4241 if (SemaRef.Context.hasSameUnqualifiedType(T1: BaseType, T2: Base.getType())) {
4242 // We found a direct base of this type. That's what we're
4243 // initializing.
4244 DirectBaseSpec = &Base;
4245 break;
4246 }
4247 }
4248
4249 // Check for a virtual base class.
4250 // FIXME: We might be able to short-circuit this if we know in advance that
4251 // there are no virtual bases.
4252 VirtualBaseSpec = nullptr;
4253 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
4254 // We haven't found a base yet; search the class hierarchy for a
4255 // virtual base class.
4256 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
4257 /*DetectVirtual=*/false);
4258 if (SemaRef.IsDerivedFrom(Loc: ClassDecl->getLocation(),
4259 Derived: SemaRef.Context.getCanonicalTagType(TD: ClassDecl),
4260 Base: BaseType, Paths)) {
4261 for (const CXXBasePath &Path : Paths) {
4262 if (Path.back().Base->isVirtual()) {
4263 VirtualBaseSpec = Path.back().Base;
4264 break;
4265 }
4266 }
4267 }
4268 }
4269
4270 return DirectBaseSpec || VirtualBaseSpec;
4271}
4272
4273MemInitResult
4274Sema::ActOnMemInitializer(Decl *ConstructorD,
4275 Scope *S,
4276 CXXScopeSpec &SS,
4277 IdentifierInfo *MemberOrBase,
4278 ParsedType TemplateTypeTy,
4279 const DeclSpec &DS,
4280 SourceLocation IdLoc,
4281 Expr *InitList,
4282 SourceLocation EllipsisLoc) {
4283 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4284 DS, IdLoc, Init: InitList,
4285 EllipsisLoc);
4286}
4287
4288MemInitResult
4289Sema::ActOnMemInitializer(Decl *ConstructorD,
4290 Scope *S,
4291 CXXScopeSpec &SS,
4292 IdentifierInfo *MemberOrBase,
4293 ParsedType TemplateTypeTy,
4294 const DeclSpec &DS,
4295 SourceLocation IdLoc,
4296 SourceLocation LParenLoc,
4297 ArrayRef<Expr *> Args,
4298 SourceLocation RParenLoc,
4299 SourceLocation EllipsisLoc) {
4300 Expr *List = ParenListExpr::Create(Ctx: Context, LParenLoc, Exprs: Args, RParenLoc);
4301 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4302 DS, IdLoc, Init: List, EllipsisLoc);
4303}
4304
4305namespace {
4306
4307// Callback to only accept typo corrections that can be a valid C++ member
4308// initializer: either a non-static field member or a base class.
4309class MemInitializerValidatorCCC final : public CorrectionCandidateCallback {
4310public:
4311 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
4312 : ClassDecl(ClassDecl) {}
4313
4314 bool ValidateCandidate(const TypoCorrection &candidate) override {
4315 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
4316 if (FieldDecl *Member = dyn_cast<FieldDecl>(Val: ND))
4317 return Member->getDeclContext()->getRedeclContext()->Equals(DC: ClassDecl);
4318 return isa<TypeDecl>(Val: ND);
4319 }
4320 return false;
4321 }
4322
4323 std::unique_ptr<CorrectionCandidateCallback> clone() override {
4324 return std::make_unique<MemInitializerValidatorCCC>(args&: *this);
4325 }
4326
4327private:
4328 CXXRecordDecl *ClassDecl;
4329};
4330
4331}
4332
4333bool Sema::DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc,
4334 RecordDecl *ClassDecl,
4335 const IdentifierInfo *Name) {
4336 DeclContextLookupResult Result = ClassDecl->lookup(Name);
4337 DeclContextLookupResult::iterator Found =
4338 llvm::find_if(Range&: Result, P: [this](const NamedDecl *Elem) {
4339 return isa<FieldDecl, IndirectFieldDecl>(Val: Elem) &&
4340 Elem->isPlaceholderVar(LangOpts: getLangOpts());
4341 });
4342 // We did not find a placeholder variable
4343 if (Found == Result.end())
4344 return false;
4345 Diag(Loc, DiagID: diag::err_using_placeholder_variable) << Name;
4346 for (DeclContextLookupResult::iterator It = Found; It != Result.end(); It++) {
4347 const NamedDecl *ND = *It;
4348 if (ND->getDeclContext() != ND->getDeclContext())
4349 break;
4350 if (isa<FieldDecl, IndirectFieldDecl>(Val: ND) &&
4351 ND->isPlaceholderVar(LangOpts: getLangOpts()))
4352 Diag(Loc: ND->getLocation(), DiagID: diag::note_reference_placeholder) << ND;
4353 }
4354 return true;
4355}
4356
4357ValueDecl *
4358Sema::tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl,
4359 const IdentifierInfo *MemberOrBase) {
4360 ValueDecl *ND = nullptr;
4361 for (auto *D : ClassDecl->lookup(Name: MemberOrBase)) {
4362 if (isa<FieldDecl, IndirectFieldDecl>(Val: D)) {
4363 bool IsPlaceholder = D->isPlaceholderVar(LangOpts: getLangOpts());
4364 if (ND) {
4365 if (IsPlaceholder && D->getDeclContext() == ND->getDeclContext())
4366 return nullptr;
4367 break;
4368 }
4369 if (!IsPlaceholder)
4370 return cast<ValueDecl>(Val: D);
4371 ND = cast<ValueDecl>(Val: D);
4372 }
4373 }
4374 return ND;
4375}
4376
4377ValueDecl *Sema::tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
4378 CXXScopeSpec &SS,
4379 ParsedType TemplateTypeTy,
4380 IdentifierInfo *MemberOrBase) {
4381 if (SS.getScopeRep() || TemplateTypeTy)
4382 return nullptr;
4383 return tryLookupUnambiguousFieldDecl(ClassDecl, MemberOrBase);
4384}
4385
4386MemInitResult
4387Sema::BuildMemInitializer(Decl *ConstructorD,
4388 Scope *S,
4389 CXXScopeSpec &SS,
4390 IdentifierInfo *MemberOrBase,
4391 ParsedType TemplateTypeTy,
4392 const DeclSpec &DS,
4393 SourceLocation IdLoc,
4394 Expr *Init,
4395 SourceLocation EllipsisLoc) {
4396 if (!ConstructorD || !Init)
4397 return true;
4398
4399 AdjustDeclIfTemplate(Decl&: ConstructorD);
4400
4401 CXXConstructorDecl *Constructor
4402 = dyn_cast<CXXConstructorDecl>(Val: ConstructorD);
4403 if (!Constructor) {
4404 // The user wrote a constructor initializer on a function that is
4405 // not a C++ constructor. Ignore the error for now, because we may
4406 // have more member initializers coming; we'll diagnose it just
4407 // once in ActOnMemInitializers.
4408 return true;
4409 }
4410
4411 CXXRecordDecl *ClassDecl = Constructor->getParent();
4412
4413 // C++ [class.base.init]p2:
4414 // Names in a mem-initializer-id are looked up in the scope of the
4415 // constructor's class and, if not found in that scope, are looked
4416 // up in the scope containing the constructor's definition.
4417 // [Note: if the constructor's class contains a member with the
4418 // same name as a direct or virtual base class of the class, a
4419 // mem-initializer-id naming the member or base class and composed
4420 // of a single identifier refers to the class member. A
4421 // mem-initializer-id for the hidden base class may be specified
4422 // using a qualified name. ]
4423
4424 // Look for a member, first.
4425 if (ValueDecl *Member = tryLookupCtorInitMemberDecl(
4426 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4427 if (EllipsisLoc.isValid())
4428 Diag(Loc: EllipsisLoc, DiagID: diag::err_pack_expansion_member_init)
4429 << MemberOrBase
4430 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4431
4432 return BuildMemberInitializer(Member, Init, IdLoc);
4433 }
4434 // It didn't name a member, so see if it names a class.
4435 QualType BaseType;
4436 TypeSourceInfo *TInfo = nullptr;
4437
4438 if (TemplateTypeTy) {
4439 BaseType = GetTypeFromParser(Ty: TemplateTypeTy, TInfo: &TInfo);
4440 if (BaseType.isNull())
4441 return true;
4442 } else if (DS.getTypeSpecType() == TST_decltype) {
4443 BaseType = BuildDecltypeType(E: DS.getRepAsExpr());
4444 } else if (DS.getTypeSpecType() == TST_decltype_auto) {
4445 Diag(Loc: DS.getTypeSpecTypeLoc(), DiagID: diag::err_decltype_auto_invalid);
4446 return true;
4447 } else if (DS.getTypeSpecType() == TST_typename_pack_indexing) {
4448 BaseType =
4449 BuildPackIndexingType(Pattern: DS.getRepAsType().get(), IndexExpr: DS.getPackIndexingExpr(),
4450 Loc: DS.getBeginLoc(), EllipsisLoc: DS.getEllipsisLoc());
4451 } else {
4452 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
4453 LookupParsedName(R, S, SS: &SS, /*ObjectType=*/QualType());
4454
4455 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
4456 if (!TyD) {
4457 if (R.isAmbiguous()) return true;
4458
4459 // We don't want access-control diagnostics here.
4460 R.suppressDiagnostics();
4461
4462 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
4463 bool NotUnknownSpecialization = false;
4464 DeclContext *DC = computeDeclContext(SS, EnteringContext: false);
4465 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(Val: DC))
4466 NotUnknownSpecialization = !Record->hasAnyDependentBases();
4467
4468 if (!NotUnknownSpecialization) {
4469 // When the scope specifier can refer to a member of an unknown
4470 // specialization, we take it as a type name.
4471 BaseType = CheckTypenameType(
4472 Keyword: ElaboratedTypeKeyword::None, KeywordLoc: SourceLocation(),
4473 QualifierLoc: SS.getWithLocInContext(Context), II: *MemberOrBase, IILoc: IdLoc);
4474 if (BaseType.isNull())
4475 return true;
4476
4477 TInfo = Context.CreateTypeSourceInfo(T: BaseType);
4478 DependentNameTypeLoc TL =
4479 TInfo->getTypeLoc().castAs<DependentNameTypeLoc>();
4480 if (!TL.isNull()) {
4481 TL.setNameLoc(IdLoc);
4482 TL.setElaboratedKeywordLoc(SourceLocation());
4483 TL.setQualifierLoc(SS.getWithLocInContext(Context));
4484 }
4485
4486 R.clear();
4487 R.setLookupName(MemberOrBase);
4488 }
4489 }
4490
4491 if (getLangOpts().MSVCCompat && !getLangOpts().CPlusPlus20) {
4492 if (auto UnqualifiedBase = R.getAsSingle<ClassTemplateDecl>()) {
4493 auto *TempSpec = cast<TemplateSpecializationType>(
4494 Val: UnqualifiedBase->getCanonicalInjectedSpecializationType(Ctx: Context));
4495 TemplateName TN = TempSpec->getTemplateName();
4496 for (auto const &Base : ClassDecl->bases()) {
4497 auto BaseTemplate =
4498 Base.getType()->getAs<TemplateSpecializationType>();
4499 if (BaseTemplate &&
4500 Context.hasSameTemplateName(X: BaseTemplate->getTemplateName(), Y: TN,
4501 /*IgnoreDeduced=*/true)) {
4502 Diag(Loc: IdLoc, DiagID: diag::ext_unqualified_base_class)
4503 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4504 BaseType = Base.getType();
4505 break;
4506 }
4507 }
4508 }
4509 }
4510
4511 // If no results were found, try to correct typos.
4512 TypoCorrection Corr;
4513 MemInitializerValidatorCCC CCC(ClassDecl);
4514 if (R.empty() && BaseType.isNull() &&
4515 (Corr =
4516 CorrectTypo(Typo: R.getLookupNameInfo(), LookupKind: R.getLookupKind(), S, SS: &SS,
4517 CCC, Mode: CorrectTypoKind::ErrorRecovery, MemberContext: ClassDecl))) {
4518 if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
4519 // We have found a non-static data member with a similar
4520 // name to what was typed; complain and initialize that
4521 // member.
4522 diagnoseTypo(Correction: Corr,
4523 TypoDiag: PDiag(DiagID: diag::err_mem_init_not_member_or_class_suggest)
4524 << MemberOrBase << true);
4525 return BuildMemberInitializer(Member, Init, IdLoc);
4526 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
4527 const CXXBaseSpecifier *DirectBaseSpec;
4528 const CXXBaseSpecifier *VirtualBaseSpec;
4529 if (FindBaseInitializer(SemaRef&: *this, ClassDecl,
4530 BaseType: Context.getTypeDeclType(Decl: Type),
4531 DirectBaseSpec, VirtualBaseSpec)) {
4532 // We have found a direct or virtual base class with a
4533 // similar name to what was typed; complain and initialize
4534 // that base class.
4535 diagnoseTypo(Correction: Corr,
4536 TypoDiag: PDiag(DiagID: diag::err_mem_init_not_member_or_class_suggest)
4537 << MemberOrBase << false,
4538 PrevNote: PDiag() /*Suppress note, we provide our own.*/);
4539
4540 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
4541 : VirtualBaseSpec;
4542 Diag(Loc: BaseSpec->getBeginLoc(), DiagID: diag::note_base_class_specified_here)
4543 << BaseSpec->getType() << BaseSpec->getSourceRange();
4544
4545 TyD = Type;
4546 }
4547 }
4548 }
4549
4550 if (!TyD && BaseType.isNull()) {
4551 Diag(Loc: IdLoc, DiagID: diag::err_mem_init_not_member_or_class)
4552 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
4553 return true;
4554 }
4555 }
4556
4557 if (BaseType.isNull()) {
4558 MarkAnyDeclReferenced(Loc: TyD->getLocation(), D: TyD, /*OdrUse=*/MightBeOdrUse: false);
4559
4560 TypeLocBuilder TLB;
4561 // FIXME: This is missing building the UsingType for TyD, if any.
4562 if (const auto *TD = dyn_cast<TagDecl>(Val: TyD)) {
4563 BaseType = Context.getTagType(Keyword: ElaboratedTypeKeyword::None,
4564 Qualifier: SS.getScopeRep(), TD, /*OwnsTag=*/false);
4565 auto TL = TLB.push<TagTypeLoc>(T: BaseType);
4566 TL.setElaboratedKeywordLoc(SourceLocation());
4567 TL.setQualifierLoc(SS.getWithLocInContext(Context));
4568 TL.setNameLoc(IdLoc);
4569 } else if (auto *TN = dyn_cast<TypedefNameDecl>(Val: TyD)) {
4570 BaseType = Context.getTypedefType(Keyword: ElaboratedTypeKeyword::None,
4571 Qualifier: SS.getScopeRep(), Decl: TN);
4572 TLB.push<TypedefTypeLoc>(T: BaseType).set(
4573 /*ElaboratedKeywordLoc=*/SourceLocation(),
4574 QualifierLoc: SS.getWithLocInContext(Context), NameLoc: IdLoc);
4575 } else if (auto *UD = dyn_cast<UnresolvedUsingTypenameDecl>(Val: TyD)) {
4576 BaseType = Context.getUnresolvedUsingType(Keyword: ElaboratedTypeKeyword::None,
4577 Qualifier: SS.getScopeRep(), D: UD);
4578 TLB.push<UnresolvedUsingTypeLoc>(T: BaseType).set(
4579 /*ElaboratedKeywordLoc=*/SourceLocation(),
4580 QualifierLoc: SS.getWithLocInContext(Context), NameLoc: IdLoc);
4581 } else {
4582 // FIXME: What else can appear here?
4583 assert(SS.isEmpty());
4584 BaseType = Context.getTypeDeclType(Decl: TyD);
4585 TLB.pushTypeSpec(T: BaseType).setNameLoc(IdLoc);
4586 }
4587 TInfo = TLB.getTypeSourceInfo(Context, T: BaseType);
4588 }
4589 }
4590
4591 if (!TInfo)
4592 TInfo = Context.getTrivialTypeSourceInfo(T: BaseType, Loc: IdLoc);
4593
4594 return BuildBaseInitializer(BaseType, BaseTInfo: TInfo, Init, ClassDecl, EllipsisLoc);
4595}
4596
4597MemInitResult
4598Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
4599 SourceLocation IdLoc) {
4600 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Val: Member);
4601 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Val: Member);
4602 assert((DirectMember || IndirectMember) &&
4603 "Member must be a FieldDecl or IndirectFieldDecl");
4604
4605 if (DiagnoseUnexpandedParameterPack(E: Init, UPPC: UPPC_Initializer))
4606 return true;
4607
4608 if (Member->isInvalidDecl())
4609 return true;
4610
4611 MultiExprArg Args;
4612 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Val: Init)) {
4613 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4614 } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Val: Init)) {
4615 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
4616 } else {
4617 // Template instantiation doesn't reconstruct ParenListExprs for us.
4618 Args = Init;
4619 }
4620
4621 SourceRange InitRange = Init->getSourceRange();
4622
4623 if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
4624 // Can't check initialization for a member of dependent type or when
4625 // any of the arguments are type-dependent expressions.
4626 DiscardCleanupsInEvaluationContext();
4627 } else {
4628 bool InitList = false;
4629 if (isa<InitListExpr>(Val: Init)) {
4630 InitList = true;
4631 Args = Init;
4632 }
4633
4634 // Initialize the member.
4635 InitializedEntity MemberEntity =
4636 DirectMember ? InitializedEntity::InitializeMember(Member: DirectMember, Parent: nullptr)
4637 : InitializedEntity::InitializeMember(Member: IndirectMember,
4638 Parent: nullptr);
4639 InitializationKind Kind =
4640 InitList ? InitializationKind::CreateDirectList(
4641 InitLoc: IdLoc, LBraceLoc: Init->getBeginLoc(), RBraceLoc: Init->getEndLoc())
4642 : InitializationKind::CreateDirect(InitLoc: IdLoc, LParenLoc: InitRange.getBegin(),
4643 RParenLoc: InitRange.getEnd());
4644
4645 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
4646 ExprResult MemberInit = InitSeq.Perform(S&: *this, Entity: MemberEntity, Kind, Args,
4647 ResultType: nullptr);
4648 if (!MemberInit.isInvalid()) {
4649 // C++11 [class.base.init]p7:
4650 // The initialization of each base and member constitutes a
4651 // full-expression.
4652 MemberInit = ActOnFinishFullExpr(Expr: MemberInit.get(), CC: InitRange.getBegin(),
4653 /*DiscardedValue*/ false);
4654 }
4655
4656 if (MemberInit.isInvalid()) {
4657 // Args were sensible expressions but we couldn't initialize the member
4658 // from them. Preserve them in a RecoveryExpr instead.
4659 Init = CreateRecoveryExpr(Begin: InitRange.getBegin(), End: InitRange.getEnd(), SubExprs: Args,
4660 T: Member->getType())
4661 .get();
4662 if (!Init)
4663 return true;
4664 } else {
4665 Init = MemberInit.get();
4666 }
4667 }
4668
4669 if (DirectMember) {
4670 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
4671 InitRange.getBegin(), Init,
4672 InitRange.getEnd());
4673 } else {
4674 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
4675 InitRange.getBegin(), Init,
4676 InitRange.getEnd());
4677 }
4678}
4679
4680MemInitResult
4681Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init,
4682 CXXRecordDecl *ClassDecl) {
4683 SourceLocation NameLoc = TInfo->getTypeLoc().getSourceRange().getBegin();
4684 if (!LangOpts.CPlusPlus11)
4685 return Diag(Loc: NameLoc, DiagID: diag::err_delegating_ctor)
4686 << TInfo->getTypeLoc().getSourceRange();
4687 Diag(Loc: NameLoc, DiagID: diag::warn_cxx98_compat_delegating_ctor);
4688
4689 bool InitList = true;
4690 MultiExprArg Args = Init;
4691 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Val: Init)) {
4692 InitList = false;
4693 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4694 }
4695
4696 CanQualType ClassType = Context.getCanonicalTagType(TD: ClassDecl);
4697
4698 SourceRange InitRange = Init->getSourceRange();
4699 // Initialize the object.
4700 InitializedEntity DelegationEntity =
4701 InitializedEntity::InitializeDelegation(Type: ClassType);
4702 InitializationKind Kind =
4703 InitList ? InitializationKind::CreateDirectList(
4704 InitLoc: NameLoc, LBraceLoc: Init->getBeginLoc(), RBraceLoc: Init->getEndLoc())
4705 : InitializationKind::CreateDirect(InitLoc: NameLoc, LParenLoc: InitRange.getBegin(),
4706 RParenLoc: InitRange.getEnd());
4707 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
4708 ExprResult DelegationInit = InitSeq.Perform(S&: *this, Entity: DelegationEntity, Kind,
4709 Args, ResultType: nullptr);
4710 if (!DelegationInit.isInvalid()) {
4711 assert((DelegationInit.get()->containsErrors() ||
4712 cast<CXXConstructExpr>(DelegationInit.get())->getConstructor()) &&
4713 "Delegating constructor with no target?");
4714
4715 // C++11 [class.base.init]p7:
4716 // The initialization of each base and member constitutes a
4717 // full-expression.
4718 DelegationInit = ActOnFinishFullExpr(
4719 Expr: DelegationInit.get(), CC: InitRange.getBegin(), /*DiscardedValue*/ false);
4720 }
4721
4722 if (DelegationInit.isInvalid()) {
4723 DelegationInit = CreateRecoveryExpr(Begin: InitRange.getBegin(),
4724 End: InitRange.getEnd(), SubExprs: Args, T: ClassType);
4725 if (DelegationInit.isInvalid())
4726 return true;
4727 } else {
4728 // If we are in a dependent context, template instantiation will
4729 // perform this type-checking again. Just save the arguments that we
4730 // received in a ParenListExpr.
4731 // FIXME: This isn't quite ideal, since our ASTs don't capture all
4732 // of the information that we have about the base
4733 // initializer. However, deconstructing the ASTs is a dicey process,
4734 // and this approach is far more likely to get the corner cases right.
4735 if (CurContext->isDependentContext())
4736 DelegationInit = Init;
4737 }
4738
4739 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
4740 DelegationInit.getAs<Expr>(),
4741 InitRange.getEnd());
4742}
4743
4744MemInitResult
4745Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
4746 Expr *Init, CXXRecordDecl *ClassDecl,
4747 SourceLocation EllipsisLoc) {
4748 SourceLocation BaseLoc = BaseTInfo->getTypeLoc().getBeginLoc();
4749
4750 if (!BaseType->isDependentType() && !BaseType->isRecordType())
4751 return Diag(Loc: BaseLoc, DiagID: diag::err_base_init_does_not_name_class)
4752 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
4753
4754 // C++ [class.base.init]p2:
4755 // [...] Unless the mem-initializer-id names a nonstatic data
4756 // member of the constructor's class or a direct or virtual base
4757 // of that class, the mem-initializer is ill-formed. A
4758 // mem-initializer-list can initialize a base class using any
4759 // name that denotes that base class type.
4760
4761 // We can store the initializers in "as-written" form and delay analysis until
4762 // instantiation if the constructor is dependent. But not for dependent
4763 // (broken) code in a non-template! SetCtorInitializers does not expect this.
4764 bool Dependent = CurContext->isDependentContext() &&
4765 (BaseType->isDependentType() || Init->isTypeDependent());
4766
4767 SourceRange InitRange = Init->getSourceRange();
4768 if (EllipsisLoc.isValid()) {
4769 // This is a pack expansion.
4770 if (!BaseType->containsUnexpandedParameterPack()) {
4771 Diag(Loc: EllipsisLoc, DiagID: diag::err_pack_expansion_without_parameter_packs)
4772 << SourceRange(BaseLoc, InitRange.getEnd());
4773
4774 EllipsisLoc = SourceLocation();
4775 }
4776 } else {
4777 // Check for any unexpanded parameter packs.
4778 if (DiagnoseUnexpandedParameterPack(Loc: BaseLoc, T: BaseTInfo, UPPC: UPPC_Initializer))
4779 return true;
4780
4781 if (DiagnoseUnexpandedParameterPack(E: Init, UPPC: UPPC_Initializer))
4782 return true;
4783 }
4784
4785 // Check for direct and virtual base classes.
4786 const CXXBaseSpecifier *DirectBaseSpec = nullptr;
4787 const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
4788 if (!Dependent) {
4789 if (declaresSameEntity(D1: ClassDecl, D2: BaseType->getAsCXXRecordDecl()))
4790 return BuildDelegatingInitializer(TInfo: BaseTInfo, Init, ClassDecl);
4791
4792 FindBaseInitializer(SemaRef&: *this, ClassDecl, BaseType, DirectBaseSpec,
4793 VirtualBaseSpec);
4794
4795 // C++ [base.class.init]p2:
4796 // Unless the mem-initializer-id names a nonstatic data member of the
4797 // constructor's class or a direct or virtual base of that class, the
4798 // mem-initializer is ill-formed.
4799 if (!DirectBaseSpec && !VirtualBaseSpec) {
4800 // If the class has any dependent bases, then it's possible that
4801 // one of those types will resolve to the same type as
4802 // BaseType. Therefore, just treat this as a dependent base
4803 // class initialization. FIXME: Should we try to check the
4804 // initialization anyway? It seems odd.
4805 if (ClassDecl->hasAnyDependentBases())
4806 Dependent = true;
4807 else
4808 return Diag(Loc: BaseLoc, DiagID: diag::err_not_direct_base_or_virtual)
4809 << BaseType << Context.getCanonicalTagType(TD: ClassDecl)
4810 << BaseTInfo->getTypeLoc().getSourceRange();
4811 }
4812 }
4813
4814 if (Dependent) {
4815 DiscardCleanupsInEvaluationContext();
4816
4817 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4818 /*IsVirtual=*/false,
4819 InitRange.getBegin(), Init,
4820 InitRange.getEnd(), EllipsisLoc);
4821 }
4822
4823 // C++ [base.class.init]p2:
4824 // If a mem-initializer-id is ambiguous because it designates both
4825 // a direct non-virtual base class and an inherited virtual base
4826 // class, the mem-initializer is ill-formed.
4827 if (DirectBaseSpec && VirtualBaseSpec)
4828 return Diag(Loc: BaseLoc, DiagID: diag::err_base_init_direct_and_virtual)
4829 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4830
4831 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
4832 if (!BaseSpec)
4833 BaseSpec = VirtualBaseSpec;
4834
4835 // Initialize the base.
4836 bool InitList = true;
4837 MultiExprArg Args = Init;
4838 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Val: Init)) {
4839 InitList = false;
4840 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4841 }
4842
4843 InitializedEntity BaseEntity =
4844 InitializedEntity::InitializeBase(Context, Base: BaseSpec, IsInheritedVirtualBase: VirtualBaseSpec);
4845 InitializationKind Kind =
4846 InitList ? InitializationKind::CreateDirectList(InitLoc: BaseLoc)
4847 : InitializationKind::CreateDirect(InitLoc: BaseLoc, LParenLoc: InitRange.getBegin(),
4848 RParenLoc: InitRange.getEnd());
4849 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
4850 ExprResult BaseInit = InitSeq.Perform(S&: *this, Entity: BaseEntity, Kind, Args, ResultType: nullptr);
4851 if (!BaseInit.isInvalid()) {
4852 // C++11 [class.base.init]p7:
4853 // The initialization of each base and member constitutes a
4854 // full-expression.
4855 BaseInit = ActOnFinishFullExpr(Expr: BaseInit.get(), CC: InitRange.getBegin(),
4856 /*DiscardedValue*/ false);
4857 }
4858
4859 if (BaseInit.isInvalid()) {
4860 BaseInit = CreateRecoveryExpr(Begin: InitRange.getBegin(), End: InitRange.getEnd(),
4861 SubExprs: Args, T: BaseType);
4862 if (BaseInit.isInvalid())
4863 return true;
4864 } else {
4865 // If we are in a dependent context, template instantiation will
4866 // perform this type-checking again. Just save the arguments that we
4867 // received in a ParenListExpr.
4868 // FIXME: This isn't quite ideal, since our ASTs don't capture all
4869 // of the information that we have about the base
4870 // initializer. However, deconstructing the ASTs is a dicey process,
4871 // and this approach is far more likely to get the corner cases right.
4872 if (CurContext->isDependentContext())
4873 BaseInit = Init;
4874 }
4875
4876 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4877 BaseSpec->isVirtual(),
4878 InitRange.getBegin(),
4879 BaseInit.getAs<Expr>(),
4880 InitRange.getEnd(), EllipsisLoc);
4881}
4882
4883// Create a static_cast\<T&&>(expr).
4884static Expr *CastForMoving(Sema &SemaRef, Expr *E) {
4885 QualType TargetType =
4886 SemaRef.BuildReferenceType(T: E->getType(), /*SpelledAsLValue*/ LValueRef: false,
4887 Loc: SourceLocation(), Entity: DeclarationName());
4888 SourceLocation ExprLoc = E->getBeginLoc();
4889 TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
4890 T: TargetType, Loc: ExprLoc);
4891
4892 return SemaRef.BuildCXXNamedCast(OpLoc: ExprLoc, Kind: tok::kw_static_cast, Ty: TargetLoc, E,
4893 AngleBrackets: SourceRange(ExprLoc, ExprLoc),
4894 Parens: E->getSourceRange()).get();
4895}
4896
4897/// ImplicitInitializerKind - How an implicit base or member initializer should
4898/// initialize its base or member.
4899enum ImplicitInitializerKind {
4900 IIK_Default,
4901 IIK_Copy,
4902 IIK_Move,
4903 IIK_Inherit
4904};
4905
4906static bool
4907BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
4908 ImplicitInitializerKind ImplicitInitKind,
4909 CXXBaseSpecifier *BaseSpec,
4910 bool IsInheritedVirtualBase,
4911 CXXCtorInitializer *&CXXBaseInit) {
4912 InitializedEntity InitEntity
4913 = InitializedEntity::InitializeBase(Context&: SemaRef.Context, Base: BaseSpec,
4914 IsInheritedVirtualBase);
4915
4916 ExprResult BaseInit;
4917
4918 switch (ImplicitInitKind) {
4919 case IIK_Inherit:
4920 case IIK_Default: {
4921 InitializationKind InitKind
4922 = InitializationKind::CreateDefault(InitLoc: Constructor->getLocation());
4923 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, {});
4924 BaseInit = InitSeq.Perform(S&: SemaRef, Entity: InitEntity, Kind: InitKind, Args: {});
4925 break;
4926 }
4927
4928 case IIK_Move:
4929 case IIK_Copy: {
4930 bool Moving = ImplicitInitKind == IIK_Move;
4931 ParmVarDecl *Param = Constructor->getParamDecl(i: 0);
4932 QualType ParamType = Param->getType().getNonReferenceType();
4933
4934 Expr *CopyCtorArg =
4935 DeclRefExpr::Create(Context: SemaRef.Context, QualifierLoc: NestedNameSpecifierLoc(),
4936 TemplateKWLoc: SourceLocation(), D: Param, RefersToEnclosingVariableOrCapture: false,
4937 NameLoc: Constructor->getLocation(), T: ParamType,
4938 VK: VK_LValue, FoundD: nullptr);
4939
4940 SemaRef.MarkDeclRefReferenced(E: cast<DeclRefExpr>(Val: CopyCtorArg));
4941
4942 // Cast to the base class to avoid ambiguities.
4943 QualType ArgTy =
4944 SemaRef.Context.getQualifiedType(T: BaseSpec->getType().getUnqualifiedType(),
4945 Qs: ParamType.getQualifiers());
4946
4947 if (Moving) {
4948 CopyCtorArg = CastForMoving(SemaRef, E: CopyCtorArg);
4949 }
4950
4951 CXXCastPath BasePath;
4952 BasePath.push_back(Elt: BaseSpec);
4953 CopyCtorArg = SemaRef.ImpCastExprToType(E: CopyCtorArg, Type: ArgTy,
4954 CK: CK_UncheckedDerivedToBase,
4955 VK: Moving ? VK_XValue : VK_LValue,
4956 BasePath: &BasePath).get();
4957
4958 InitializationKind InitKind
4959 = InitializationKind::CreateDirect(InitLoc: Constructor->getLocation(),
4960 LParenLoc: SourceLocation(), RParenLoc: SourceLocation());
4961 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
4962 BaseInit = InitSeq.Perform(S&: SemaRef, Entity: InitEntity, Kind: InitKind, Args: CopyCtorArg);
4963 break;
4964 }
4965 }
4966
4967 BaseInit = SemaRef.MaybeCreateExprWithCleanups(SubExpr: BaseInit);
4968 if (BaseInit.isInvalid())
4969 return true;
4970
4971 CXXBaseInit =
4972 new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4973 SemaRef.Context.getTrivialTypeSourceInfo(T: BaseSpec->getType(),
4974 Loc: SourceLocation()),
4975 BaseSpec->isVirtual(),
4976 SourceLocation(),
4977 BaseInit.getAs<Expr>(),
4978 SourceLocation(),
4979 SourceLocation());
4980
4981 return false;
4982}
4983
4984static bool RefersToRValueRef(Expr *MemRef) {
4985 ValueDecl *Referenced = cast<MemberExpr>(Val: MemRef)->getMemberDecl();
4986 return Referenced->getType()->isRValueReferenceType();
4987}
4988
4989static bool
4990BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
4991 ImplicitInitializerKind ImplicitInitKind,
4992 FieldDecl *Field, IndirectFieldDecl *Indirect,
4993 CXXCtorInitializer *&CXXMemberInit) {
4994 if (Field->isInvalidDecl())
4995 return true;
4996
4997 SourceLocation Loc = Constructor->getLocation();
4998
4999 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
5000 bool Moving = ImplicitInitKind == IIK_Move;
5001 ParmVarDecl *Param = Constructor->getParamDecl(i: 0);
5002 QualType ParamType = Param->getType().getNonReferenceType();
5003
5004 // Suppress copying zero-width bitfields.
5005 if (Field->isZeroLengthBitField())
5006 return false;
5007
5008 Expr *MemberExprBase =
5009 DeclRefExpr::Create(Context: SemaRef.Context, QualifierLoc: NestedNameSpecifierLoc(),
5010 TemplateKWLoc: SourceLocation(), D: Param, RefersToEnclosingVariableOrCapture: false,
5011 NameLoc: Loc, T: ParamType, VK: VK_LValue, FoundD: nullptr);
5012
5013 SemaRef.MarkDeclRefReferenced(E: cast<DeclRefExpr>(Val: MemberExprBase));
5014
5015 if (Moving) {
5016 MemberExprBase = CastForMoving(SemaRef, E: MemberExprBase);
5017 }
5018
5019 // Build a reference to this field within the parameter.
5020 CXXScopeSpec SS;
5021 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
5022 Sema::LookupMemberName);
5023 MemberLookup.addDecl(D: Indirect ? cast<ValueDecl>(Val: Indirect)
5024 : cast<ValueDecl>(Val: Field), AS: AS_public);
5025 MemberLookup.resolveKind();
5026 ExprResult CtorArg
5027 = SemaRef.BuildMemberReferenceExpr(Base: MemberExprBase,
5028 BaseType: ParamType, OpLoc: Loc,
5029 /*IsArrow=*/false,
5030 SS,
5031 /*TemplateKWLoc=*/SourceLocation(),
5032 /*FirstQualifierInScope=*/nullptr,
5033 R&: MemberLookup,
5034 /*TemplateArgs=*/nullptr,
5035 /*S*/nullptr);
5036 if (CtorArg.isInvalid())
5037 return true;
5038
5039 // C++11 [class.copy]p15:
5040 // - if a member m has rvalue reference type T&&, it is direct-initialized
5041 // with static_cast<T&&>(x.m);
5042 if (RefersToRValueRef(MemRef: CtorArg.get())) {
5043 CtorArg = CastForMoving(SemaRef, E: CtorArg.get());
5044 }
5045
5046 InitializedEntity Entity =
5047 Indirect ? InitializedEntity::InitializeMember(Member: Indirect, Parent: nullptr,
5048 /*Implicit*/ true)
5049 : InitializedEntity::InitializeMember(Member: Field, Parent: nullptr,
5050 /*Implicit*/ true);
5051
5052 // Direct-initialize to use the copy constructor.
5053 InitializationKind InitKind =
5054 InitializationKind::CreateDirect(InitLoc: Loc, LParenLoc: SourceLocation(), RParenLoc: SourceLocation());
5055
5056 Expr *CtorArgE = CtorArg.getAs<Expr>();
5057 InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
5058 ExprResult MemberInit =
5059 InitSeq.Perform(S&: SemaRef, Entity, Kind: InitKind, Args: MultiExprArg(&CtorArgE, 1));
5060 MemberInit = SemaRef.MaybeCreateExprWithCleanups(SubExpr: MemberInit);
5061 if (MemberInit.isInvalid())
5062 return true;
5063
5064 if (Indirect)
5065 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
5066 SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
5067 else
5068 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
5069 SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
5070 return false;
5071 }
5072
5073 assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
5074 "Unhandled implicit init kind!");
5075
5076 QualType FieldBaseElementType =
5077 SemaRef.Context.getBaseElementType(QT: Field->getType());
5078
5079 if (FieldBaseElementType->isRecordType()) {
5080 InitializedEntity InitEntity =
5081 Indirect ? InitializedEntity::InitializeMember(Member: Indirect, Parent: nullptr,
5082 /*Implicit*/ true)
5083 : InitializedEntity::InitializeMember(Member: Field, Parent: nullptr,
5084 /*Implicit*/ true);
5085 InitializationKind InitKind =
5086 InitializationKind::CreateDefault(InitLoc: Loc);
5087
5088 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, {});
5089 ExprResult MemberInit = InitSeq.Perform(S&: SemaRef, Entity: InitEntity, Kind: InitKind, Args: {});
5090
5091 MemberInit = SemaRef.MaybeCreateExprWithCleanups(SubExpr: MemberInit);
5092 if (MemberInit.isInvalid())
5093 return true;
5094
5095 if (Indirect)
5096 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
5097 Indirect, Loc,
5098 Loc,
5099 MemberInit.get(),
5100 Loc);
5101 else
5102 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
5103 Field, Loc, Loc,
5104 MemberInit.get(),
5105 Loc);
5106 return false;
5107 }
5108
5109 if (!Field->getParent()->isUnion()) {
5110 if (FieldBaseElementType->isReferenceType()) {
5111 SemaRef.Diag(Loc: Constructor->getLocation(),
5112 DiagID: diag::err_uninitialized_member_in_ctor)
5113 << (int)Constructor->isImplicit()
5114 << SemaRef.Context.getCanonicalTagType(TD: Constructor->getParent()) << 0
5115 << Field->getDeclName();
5116 SemaRef.Diag(Loc: Field->getLocation(), DiagID: diag::note_declared_at);
5117 return true;
5118 }
5119
5120 if (FieldBaseElementType.isConstQualified()) {
5121 SemaRef.Diag(Loc: Constructor->getLocation(),
5122 DiagID: diag::err_uninitialized_member_in_ctor)
5123 << (int)Constructor->isImplicit()
5124 << SemaRef.Context.getCanonicalTagType(TD: Constructor->getParent()) << 1
5125 << Field->getDeclName();
5126 SemaRef.Diag(Loc: Field->getLocation(), DiagID: diag::note_declared_at);
5127 return true;
5128 }
5129 }
5130
5131 if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
5132 // ARC and Weak:
5133 // Default-initialize Objective-C pointers to NULL.
5134 CXXMemberInit
5135 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
5136 Loc, Loc,
5137 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
5138 Loc);
5139 return false;
5140 }
5141
5142 // Nothing to initialize.
5143 CXXMemberInit = nullptr;
5144 return false;
5145}
5146
5147namespace {
5148struct BaseAndFieldInfo {
5149 Sema &S;
5150 CXXConstructorDecl *Ctor;
5151 bool AnyErrorsInInits;
5152 ImplicitInitializerKind IIK;
5153 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
5154 SmallVector<CXXCtorInitializer*, 8> AllToInit;
5155 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
5156
5157 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
5158 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
5159 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
5160 if (Ctor->getInheritedConstructor())
5161 IIK = IIK_Inherit;
5162 else if (Generated && Ctor->isCopyConstructor())
5163 IIK = IIK_Copy;
5164 else if (Generated && Ctor->isMoveConstructor())
5165 IIK = IIK_Move;
5166 else
5167 IIK = IIK_Default;
5168 }
5169
5170 bool isImplicitCopyOrMove() const {
5171 switch (IIK) {
5172 case IIK_Copy:
5173 case IIK_Move:
5174 return true;
5175
5176 case IIK_Default:
5177 case IIK_Inherit:
5178 return false;
5179 }
5180
5181 llvm_unreachable("Invalid ImplicitInitializerKind!");
5182 }
5183
5184 bool addFieldInitializer(CXXCtorInitializer *Init) {
5185 AllToInit.push_back(Elt: Init);
5186
5187 // Check whether this initializer makes the field "used".
5188 if (Init->getInit()->HasSideEffects(Ctx: S.Context))
5189 S.UnusedPrivateFields.remove(X: Init->getAnyMember());
5190
5191 return false;
5192 }
5193
5194 bool isInactiveUnionMember(FieldDecl *Field) {
5195 RecordDecl *Record = Field->getParent();
5196 if (!Record->isUnion())
5197 return false;
5198
5199 if (FieldDecl *Active =
5200 ActiveUnionMember.lookup(Val: Record->getCanonicalDecl()))
5201 return Active != Field->getCanonicalDecl();
5202
5203 // In an implicit copy or move constructor, ignore any in-class initializer.
5204 if (isImplicitCopyOrMove())
5205 return true;
5206
5207 // If there's no explicit initialization, the field is active only if it
5208 // has an in-class initializer...
5209 if (Field->hasInClassInitializer())
5210 return false;
5211 // ... or it's an anonymous struct or union whose class has an in-class
5212 // initializer.
5213 if (!Field->isAnonymousStructOrUnion())
5214 return true;
5215 CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
5216 return !FieldRD->hasInClassInitializer();
5217 }
5218
5219 /// Determine whether the given field is, or is within, a union member
5220 /// that is inactive (because there was an initializer given for a different
5221 /// member of the union, or because the union was not initialized at all).
5222 bool isWithinInactiveUnionMember(FieldDecl *Field,
5223 IndirectFieldDecl *Indirect) {
5224 if (!Indirect)
5225 return isInactiveUnionMember(Field);
5226
5227 for (auto *C : Indirect->chain()) {
5228 FieldDecl *Field = dyn_cast<FieldDecl>(Val: C);
5229 if (Field && isInactiveUnionMember(Field))
5230 return true;
5231 }
5232 return false;
5233 }
5234};
5235}
5236
5237/// Determine whether the given type is an incomplete or zero-lenfgth
5238/// array type.
5239static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) {
5240 if (T->isIncompleteArrayType())
5241 return true;
5242
5243 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
5244 if (ArrayT->isZeroSize())
5245 return true;
5246
5247 T = ArrayT->getElementType();
5248 }
5249
5250 return false;
5251}
5252
5253static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
5254 FieldDecl *Field,
5255 IndirectFieldDecl *Indirect = nullptr) {
5256 if (Field->isInvalidDecl())
5257 return false;
5258
5259 // Overwhelmingly common case: we have a direct initializer for this field.
5260 if (CXXCtorInitializer *Init =
5261 Info.AllBaseFields.lookup(Val: Field->getCanonicalDecl()))
5262 return Info.addFieldInitializer(Init);
5263
5264 // C++11 [class.base.init]p8:
5265 // if the entity is a non-static data member that has a
5266 // brace-or-equal-initializer and either
5267 // -- the constructor's class is a union and no other variant member of that
5268 // union is designated by a mem-initializer-id or
5269 // -- the constructor's class is not a union, and, if the entity is a member
5270 // of an anonymous union, no other member of that union is designated by
5271 // a mem-initializer-id,
5272 // the entity is initialized as specified in [dcl.init].
5273 //
5274 // We also apply the same rules to handle anonymous structs within anonymous
5275 // unions.
5276 if (Info.isWithinInactiveUnionMember(Field, Indirect))
5277 return false;
5278
5279 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5280 ExprResult DIE =
5281 SemaRef.BuildCXXDefaultInitExpr(Loc: Info.Ctor->getLocation(), Field);
5282 if (DIE.isInvalid())
5283 return true;
5284
5285 auto Entity = InitializedEntity::InitializeMember(Member: Field, Parent: nullptr, Implicit: true);
5286 SemaRef.checkInitializerLifetime(Entity, Init: DIE.get());
5287
5288 CXXCtorInitializer *Init;
5289 if (Indirect)
5290 Init = new (SemaRef.Context)
5291 CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
5292 SourceLocation(), DIE.get(), SourceLocation());
5293 else
5294 Init = new (SemaRef.Context)
5295 CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
5296 SourceLocation(), DIE.get(), SourceLocation());
5297 return Info.addFieldInitializer(Init);
5298 }
5299
5300 // Don't initialize incomplete or zero-length arrays.
5301 if (isIncompleteOrZeroLengthArrayType(Context&: SemaRef.Context, T: Field->getType()))
5302 return false;
5303
5304 // Don't try to build an implicit initializer if there were semantic
5305 // errors in any of the initializers (and therefore we might be
5306 // missing some that the user actually wrote).
5307 if (Info.AnyErrorsInInits)
5308 return false;
5309
5310 CXXCtorInitializer *Init = nullptr;
5311 if (BuildImplicitMemberInitializer(SemaRef&: Info.S, Constructor: Info.Ctor, ImplicitInitKind: Info.IIK, Field,
5312 Indirect, CXXMemberInit&: Init))
5313 return true;
5314
5315 if (!Init)
5316 return false;
5317
5318 return Info.addFieldInitializer(Init);
5319}
5320
5321bool
5322Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor,
5323 CXXCtorInitializer *Initializer) {
5324 assert(Initializer->isDelegatingInitializer());
5325 Constructor->setNumCtorInitializers(1);
5326 CXXCtorInitializer **initializer =
5327 new (Context) CXXCtorInitializer*[1];
5328 memcpy(dest: initializer, src: &Initializer, n: sizeof (CXXCtorInitializer*));
5329 Constructor->setCtorInitializers(initializer);
5330
5331 if (CXXDestructorDecl *Dtor = LookupDestructor(Class: Constructor->getParent())) {
5332 MarkFunctionReferenced(Loc: Initializer->getSourceLocation(), Func: Dtor);
5333 DiagnoseUseOfDecl(D: Dtor, Locs: Initializer->getSourceLocation());
5334 }
5335
5336 DelegatingCtorDecls.push_back(LocalValue: Constructor);
5337
5338 DiagnoseUninitializedFields(SemaRef&: *this, Constructor);
5339
5340 return false;
5341}
5342
5343static CXXDestructorDecl *LookupDestructorIfRelevant(Sema &S,
5344 CXXRecordDecl *Class) {
5345 if (Class->isInvalidDecl())
5346 return nullptr;
5347 if (Class->hasIrrelevantDestructor())
5348 return nullptr;
5349
5350 // Dtor might still be missing, e.g because it's invalid.
5351 return S.LookupDestructor(Class);
5352}
5353
5354static void MarkFieldDestructorReferenced(Sema &S, SourceLocation Location,
5355 FieldDecl *Field) {
5356 if (Field->isInvalidDecl())
5357 return;
5358
5359 // Don't destroy incomplete or zero-length arrays.
5360 if (isIncompleteOrZeroLengthArrayType(Context&: S.Context, T: Field->getType()))
5361 return;
5362
5363 QualType FieldType = S.Context.getBaseElementType(QT: Field->getType());
5364
5365 auto *FieldClassDecl = FieldType->getAsCXXRecordDecl();
5366 if (!FieldClassDecl)
5367 return;
5368
5369 // The destructor for an implicit anonymous union member is never invoked.
5370 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
5371 return;
5372
5373 auto *Dtor = LookupDestructorIfRelevant(S, Class: FieldClassDecl);
5374 if (!Dtor)
5375 return;
5376
5377 S.CheckDestructorAccess(Loc: Field->getLocation(), Dtor,
5378 PDiag: S.PDiag(DiagID: diag::err_access_dtor_field)
5379 << Field->getDeclName() << FieldType);
5380
5381 S.MarkFunctionReferenced(Loc: Location, Func: Dtor);
5382 S.DiagnoseUseOfDecl(D: Dtor, Locs: Location);
5383}
5384
5385static void MarkBaseDestructorsReferenced(Sema &S, SourceLocation Location,
5386 CXXRecordDecl *ClassDecl) {
5387 if (ClassDecl->isDependentContext())
5388 return;
5389
5390 // We only potentially invoke the destructors of potentially constructed
5391 // subobjects.
5392 bool VisitVirtualBases = !ClassDecl->isAbstract();
5393
5394 // If the destructor exists and has already been marked used in the MS ABI,
5395 // then virtual base destructors have already been checked and marked used.
5396 // Skip checking them again to avoid duplicate diagnostics.
5397 if (S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5398 CXXDestructorDecl *Dtor = ClassDecl->getDestructor();
5399 if (Dtor && Dtor->isUsed())
5400 VisitVirtualBases = false;
5401 }
5402
5403 llvm::SmallPtrSet<const CXXRecordDecl *, 8> DirectVirtualBases;
5404
5405 // Bases.
5406 for (const auto &Base : ClassDecl->bases()) {
5407 auto *BaseClassDecl = Base.getType()->getAsCXXRecordDecl();
5408 if (!BaseClassDecl)
5409 continue;
5410
5411 // Remember direct virtual bases.
5412 if (Base.isVirtual()) {
5413 if (!VisitVirtualBases)
5414 continue;
5415 DirectVirtualBases.insert(Ptr: BaseClassDecl);
5416 }
5417
5418 auto *Dtor = LookupDestructorIfRelevant(S, Class: BaseClassDecl);
5419 if (!Dtor)
5420 continue;
5421
5422 // FIXME: caret should be on the start of the class name
5423 S.CheckDestructorAccess(Loc: Base.getBeginLoc(), Dtor,
5424 PDiag: S.PDiag(DiagID: diag::err_access_dtor_base)
5425 << Base.getType() << Base.getSourceRange(),
5426 objectType: S.Context.getCanonicalTagType(TD: ClassDecl));
5427
5428 S.MarkFunctionReferenced(Loc: Location, Func: Dtor);
5429 S.DiagnoseUseOfDecl(D: Dtor, Locs: Location);
5430 }
5431
5432 if (VisitVirtualBases)
5433 S.MarkVirtualBaseDestructorsReferenced(Location, ClassDecl,
5434 DirectVirtualBases: &DirectVirtualBases);
5435}
5436
5437bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
5438 ArrayRef<CXXCtorInitializer *> Initializers) {
5439 if (Constructor->isDependentContext()) {
5440 // Just store the initializers as written, they will be checked during
5441 // instantiation.
5442 if (!Initializers.empty()) {
5443 Constructor->setNumCtorInitializers(Initializers.size());
5444 CXXCtorInitializer **baseOrMemberInitializers =
5445 new (Context) CXXCtorInitializer*[Initializers.size()];
5446 memcpy(dest: baseOrMemberInitializers, src: Initializers.data(),
5447 n: Initializers.size() * sizeof(CXXCtorInitializer*));
5448 Constructor->setCtorInitializers(baseOrMemberInitializers);
5449 }
5450
5451 // Let template instantiation know whether we had errors.
5452 if (AnyErrors)
5453 Constructor->setInvalidDecl();
5454
5455 return false;
5456 }
5457
5458 BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
5459
5460 // We need to build the initializer AST according to order of construction
5461 // and not what user specified in the Initializers list.
5462 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5463 if (!ClassDecl)
5464 return true;
5465
5466 bool HadError = false;
5467
5468 for (CXXCtorInitializer *Member : Initializers) {
5469 if (Member->isBaseInitializer())
5470 Info.AllBaseFields[Member->getBaseClass()->getAsCanonical<RecordType>()] =
5471 Member;
5472 else {
5473 Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
5474
5475 if (IndirectFieldDecl *F = Member->getIndirectMember()) {
5476 for (auto *C : F->chain()) {
5477 FieldDecl *FD = dyn_cast<FieldDecl>(Val: C);
5478 if (FD && FD->getParent()->isUnion())
5479 Info.ActiveUnionMember.insert(KV: std::make_pair(
5480 x: FD->getParent()->getCanonicalDecl(), y: FD->getCanonicalDecl()));
5481 }
5482 } else if (FieldDecl *FD = Member->getMember()) {
5483 if (FD->getParent()->isUnion())
5484 Info.ActiveUnionMember.insert(KV: std::make_pair(
5485 x: FD->getParent()->getCanonicalDecl(), y: FD->getCanonicalDecl()));
5486 }
5487 }
5488 }
5489
5490 // Keep track of the direct virtual bases.
5491 llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
5492 for (auto &I : ClassDecl->bases()) {
5493 if (I.isVirtual())
5494 DirectVBases.insert(Ptr: &I);
5495 }
5496
5497 // Push virtual bases before others.
5498 for (auto &VBase : ClassDecl->vbases()) {
5499 if (CXXCtorInitializer *Value = Info.AllBaseFields.lookup(
5500 Val: VBase.getType()->getAsCanonical<RecordType>())) {
5501 // [class.base.init]p7, per DR257:
5502 // A mem-initializer where the mem-initializer-id names a virtual base
5503 // class is ignored during execution of a constructor of any class that
5504 // is not the most derived class.
5505 if (ClassDecl->isAbstract()) {
5506 // FIXME: Provide a fixit to remove the base specifier. This requires
5507 // tracking the location of the associated comma for a base specifier.
5508 Diag(Loc: Value->getSourceLocation(), DiagID: diag::warn_abstract_vbase_init_ignored)
5509 << VBase.getType() << ClassDecl;
5510 DiagnoseAbstractType(RD: ClassDecl);
5511 }
5512
5513 Info.AllToInit.push_back(Elt: Value);
5514 } else if (!AnyErrors && !ClassDecl->isAbstract()) {
5515 // [class.base.init]p8, per DR257:
5516 // If a given [...] base class is not named by a mem-initializer-id
5517 // [...] and the entity is not a virtual base class of an abstract
5518 // class, then [...] the entity is default-initialized.
5519 bool IsInheritedVirtualBase = !DirectVBases.count(Ptr: &VBase);
5520 CXXCtorInitializer *CXXBaseInit;
5521 if (BuildImplicitBaseInitializer(SemaRef&: *this, Constructor, ImplicitInitKind: Info.IIK,
5522 BaseSpec: &VBase, IsInheritedVirtualBase,
5523 CXXBaseInit)) {
5524 HadError = true;
5525 continue;
5526 }
5527
5528 Info.AllToInit.push_back(Elt: CXXBaseInit);
5529 }
5530 }
5531
5532 // Non-virtual bases.
5533 for (auto &Base : ClassDecl->bases()) {
5534 // Virtuals are in the virtual base list and already constructed.
5535 if (Base.isVirtual())
5536 continue;
5537
5538 if (CXXCtorInitializer *Value = Info.AllBaseFields.lookup(
5539 Val: Base.getType()->getAsCanonical<RecordType>())) {
5540 Info.AllToInit.push_back(Elt: Value);
5541 } else if (!AnyErrors) {
5542 CXXCtorInitializer *CXXBaseInit;
5543 if (BuildImplicitBaseInitializer(SemaRef&: *this, Constructor, ImplicitInitKind: Info.IIK,
5544 BaseSpec: &Base, /*IsInheritedVirtualBase=*/false,
5545 CXXBaseInit)) {
5546 HadError = true;
5547 continue;
5548 }
5549
5550 Info.AllToInit.push_back(Elt: CXXBaseInit);
5551 }
5552 }
5553
5554 // Fields.
5555 for (auto *Mem : ClassDecl->decls()) {
5556 if (auto *F = dyn_cast<FieldDecl>(Val: Mem)) {
5557 // C++ [class.bit]p2:
5558 // A declaration for a bit-field that omits the identifier declares an
5559 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
5560 // initialized.
5561 if (F->isUnnamedBitField())
5562 continue;
5563
5564 // If we're not generating the implicit copy/move constructor, then we'll
5565 // handle anonymous struct/union fields based on their individual
5566 // indirect fields.
5567 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5568 continue;
5569
5570 if (CollectFieldInitializer(SemaRef&: *this, Info, Field: F))
5571 HadError = true;
5572 continue;
5573 }
5574
5575 // Beyond this point, we only consider default initialization.
5576 if (Info.isImplicitCopyOrMove())
5577 continue;
5578
5579 if (auto *F = dyn_cast<IndirectFieldDecl>(Val: Mem)) {
5580 if (F->getType()->isIncompleteArrayType()) {
5581 assert(ClassDecl->hasFlexibleArrayMember() &&
5582 "Incomplete array type is not valid");
5583 continue;
5584 }
5585
5586 // Initialize each field of an anonymous struct individually.
5587 if (CollectFieldInitializer(SemaRef&: *this, Info, Field: F->getAnonField(), Indirect: F))
5588 HadError = true;
5589
5590 continue;
5591 }
5592 }
5593
5594 unsigned NumInitializers = Info.AllToInit.size();
5595 if (NumInitializers > 0) {
5596 Constructor->setNumCtorInitializers(NumInitializers);
5597 CXXCtorInitializer **baseOrMemberInitializers =
5598 new (Context) CXXCtorInitializer*[NumInitializers];
5599 memcpy(dest: baseOrMemberInitializers, src: Info.AllToInit.data(),
5600 n: NumInitializers * sizeof(CXXCtorInitializer*));
5601 Constructor->setCtorInitializers(baseOrMemberInitializers);
5602
5603 SourceLocation Location = Constructor->getLocation();
5604
5605 // Constructors implicitly reference the base and member
5606 // destructors.
5607
5608 for (CXXCtorInitializer *Initializer : Info.AllToInit) {
5609 FieldDecl *Field = Initializer->getAnyMember();
5610 if (!Field)
5611 continue;
5612
5613 // C++ [class.base.init]p12:
5614 // In a non-delegating constructor, the destructor for each
5615 // potentially constructed subobject of class type is potentially
5616 // invoked.
5617 MarkFieldDestructorReferenced(S&: *this, Location, Field);
5618 }
5619
5620 MarkBaseDestructorsReferenced(S&: *this, Location, ClassDecl: Constructor->getParent());
5621 }
5622
5623 return HadError;
5624}
5625
5626static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl<const void*> &IdealInits) {
5627 if (const RecordType *RT = Field->getType()->getAsCanonical<RecordType>()) {
5628 const RecordDecl *RD = RT->getDecl();
5629 if (RD->isAnonymousStructOrUnion()) {
5630 for (auto *Field : RD->getDefinitionOrSelf()->fields())
5631 PopulateKeysForFields(Field, IdealInits);
5632 return;
5633 }
5634 }
5635 IdealInits.push_back(Elt: Field->getCanonicalDecl());
5636}
5637
5638static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
5639 return Context.getCanonicalType(T: BaseType).getTypePtr();
5640}
5641
5642static const void *GetKeyForMember(ASTContext &Context,
5643 CXXCtorInitializer *Member) {
5644 if (!Member->isAnyMemberInitializer())
5645 return GetKeyForBase(Context, BaseType: QualType(Member->getBaseClass(), 0));
5646
5647 return Member->getAnyMember()->getCanonicalDecl();
5648}
5649
5650static void AddInitializerToDiag(const Sema::SemaDiagnosticBuilder &Diag,
5651 const CXXCtorInitializer *Previous,
5652 const CXXCtorInitializer *Current) {
5653 if (Previous->isAnyMemberInitializer())
5654 Diag << 0 << Previous->getAnyMember();
5655 else
5656 Diag << 1 << Previous->getTypeSourceInfo()->getType();
5657
5658 if (Current->isAnyMemberInitializer())
5659 Diag << 0 << Current->getAnyMember();
5660 else
5661 Diag << 1 << Current->getTypeSourceInfo()->getType();
5662}
5663
5664static void DiagnoseBaseOrMemInitializerOrder(
5665 Sema &SemaRef, const CXXConstructorDecl *Constructor,
5666 ArrayRef<CXXCtorInitializer *> Inits) {
5667 if (Constructor->getDeclContext()->isDependentContext())
5668 return;
5669
5670 // Don't check initializers order unless the warning is enabled at the
5671 // location of at least one initializer.
5672 bool ShouldCheckOrder = false;
5673 for (const CXXCtorInitializer *Init : Inits) {
5674 if (!SemaRef.Diags.isIgnored(DiagID: diag::warn_initializer_out_of_order,
5675 Loc: Init->getSourceLocation())) {
5676 ShouldCheckOrder = true;
5677 break;
5678 }
5679 }
5680 if (!ShouldCheckOrder)
5681 return;
5682
5683 // Build the list of bases and members in the order that they'll
5684 // actually be initialized. The explicit initializers should be in
5685 // this same order but may be missing things.
5686 SmallVector<const void*, 32> IdealInitKeys;
5687
5688 const CXXRecordDecl *ClassDecl = Constructor->getParent();
5689
5690 // 1. Virtual bases.
5691 for (const auto &VBase : ClassDecl->vbases())
5692 IdealInitKeys.push_back(Elt: GetKeyForBase(Context&: SemaRef.Context, BaseType: VBase.getType()));
5693
5694 // 2. Non-virtual bases.
5695 for (const auto &Base : ClassDecl->bases()) {
5696 if (Base.isVirtual())
5697 continue;
5698 IdealInitKeys.push_back(Elt: GetKeyForBase(Context&: SemaRef.Context, BaseType: Base.getType()));
5699 }
5700
5701 // 3. Direct fields.
5702 for (auto *Field : ClassDecl->fields()) {
5703 if (Field->isUnnamedBitField())
5704 continue;
5705
5706 PopulateKeysForFields(Field, IdealInits&: IdealInitKeys);
5707 }
5708
5709 unsigned NumIdealInits = IdealInitKeys.size();
5710 unsigned IdealIndex = 0;
5711
5712 // Track initializers that are in an incorrect order for either a warning or
5713 // note if multiple ones occur.
5714 SmallVector<unsigned> WarnIndexes;
5715 // Correlates the index of an initializer in the init-list to the index of
5716 // the field/base in the class.
5717 SmallVector<std::pair<unsigned, unsigned>, 32> CorrelatedInitOrder;
5718
5719 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5720 const void *InitKey = GetKeyForMember(Context&: SemaRef.Context, Member: Inits[InitIndex]);
5721
5722 // Scan forward to try to find this initializer in the idealized
5723 // initializers list.
5724 for (; IdealIndex != NumIdealInits; ++IdealIndex)
5725 if (InitKey == IdealInitKeys[IdealIndex])
5726 break;
5727
5728 // If we didn't find this initializer, it must be because we
5729 // scanned past it on a previous iteration. That can only
5730 // happen if we're out of order; emit a warning.
5731 if (IdealIndex == NumIdealInits && InitIndex) {
5732 WarnIndexes.push_back(Elt: InitIndex);
5733
5734 // Move back to the initializer's location in the ideal list.
5735 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5736 if (InitKey == IdealInitKeys[IdealIndex])
5737 break;
5738
5739 assert(IdealIndex < NumIdealInits &&
5740 "initializer not found in initializer list");
5741 }
5742 CorrelatedInitOrder.emplace_back(Args&: IdealIndex, Args&: InitIndex);
5743 }
5744
5745 if (WarnIndexes.empty())
5746 return;
5747
5748 // Sort based on the ideal order, first in the pair.
5749 llvm::sort(C&: CorrelatedInitOrder, Comp: llvm::less_first());
5750
5751 // Introduce a new scope as SemaDiagnosticBuilder needs to be destroyed to
5752 // emit the diagnostic before we can try adding notes.
5753 {
5754 Sema::SemaDiagnosticBuilder D = SemaRef.Diag(
5755 Loc: Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5756 DiagID: WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5757 : diag::warn_some_initializers_out_of_order);
5758
5759 for (unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5760 if (CorrelatedInitOrder[I].second == I)
5761 continue;
5762 // Ideally we would be using InsertFromRange here, but clang doesn't
5763 // appear to handle InsertFromRange correctly when the source range is
5764 // modified by another fix-it.
5765 D << FixItHint::CreateReplacement(
5766 RemoveRange: Inits[I]->getSourceRange(),
5767 Code: Lexer::getSourceText(
5768 Range: CharSourceRange::getTokenRange(
5769 R: Inits[CorrelatedInitOrder[I].second]->getSourceRange()),
5770 SM: SemaRef.getSourceManager(), LangOpts: SemaRef.getLangOpts()));
5771 }
5772
5773 // If there is only 1 item out of order, the warning expects the name and
5774 // type of each being added to it.
5775 if (WarnIndexes.size() == 1) {
5776 AddInitializerToDiag(Diag: D, Previous: Inits[WarnIndexes.front() - 1],
5777 Current: Inits[WarnIndexes.front()]);
5778 return;
5779 }
5780 }
5781 // More than 1 item to warn, create notes letting the user know which ones
5782 // are bad.
5783 for (unsigned WarnIndex : WarnIndexes) {
5784 const clang::CXXCtorInitializer *PrevInit = Inits[WarnIndex - 1];
5785 auto D = SemaRef.Diag(Loc: PrevInit->getSourceLocation(),
5786 DiagID: diag::note_initializer_out_of_order);
5787 AddInitializerToDiag(Diag: D, Previous: PrevInit, Current: Inits[WarnIndex]);
5788 D << PrevInit->getSourceRange();
5789 }
5790}
5791
5792namespace {
5793bool CheckRedundantInit(Sema &S,
5794 CXXCtorInitializer *Init,
5795 CXXCtorInitializer *&PrevInit) {
5796 if (!PrevInit) {
5797 PrevInit = Init;
5798 return false;
5799 }
5800
5801 if (FieldDecl *Field = Init->getAnyMember())
5802 S.Diag(Loc: Init->getSourceLocation(),
5803 DiagID: diag::err_multiple_mem_initialization)
5804 << Field->getDeclName()
5805 << Init->getSourceRange();
5806 else {
5807 const Type *BaseClass = Init->getBaseClass();
5808 assert(BaseClass && "neither field nor base");
5809 S.Diag(Loc: Init->getSourceLocation(),
5810 DiagID: diag::err_multiple_base_initialization)
5811 << QualType(BaseClass, 0)
5812 << Init->getSourceRange();
5813 }
5814 S.Diag(Loc: PrevInit->getSourceLocation(), DiagID: diag::note_previous_initializer)
5815 << 0 << PrevInit->getSourceRange();
5816
5817 return true;
5818}
5819
5820typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5821typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5822
5823bool CheckRedundantUnionInit(Sema &S,
5824 CXXCtorInitializer *Init,
5825 RedundantUnionMap &Unions) {
5826 FieldDecl *Field = Init->getAnyMember();
5827 RecordDecl *Parent = Field->getParent();
5828 NamedDecl *Child = Field;
5829
5830 while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
5831 if (Parent->isUnion()) {
5832 UnionEntry &En = Unions[Parent];
5833 if (En.first && En.first != Child) {
5834 S.Diag(Loc: Init->getSourceLocation(),
5835 DiagID: diag::err_multiple_mem_union_initialization)
5836 << Field->getDeclName()
5837 << Init->getSourceRange();
5838 S.Diag(Loc: En.second->getSourceLocation(), DiagID: diag::note_previous_initializer)
5839 << 0 << En.second->getSourceRange();
5840 return true;
5841 }
5842 if (!En.first) {
5843 En.first = Child;
5844 En.second = Init;
5845 }
5846 if (!Parent->isAnonymousStructOrUnion())
5847 return false;
5848 }
5849
5850 Child = Parent;
5851 Parent = cast<RecordDecl>(Val: Parent->getDeclContext());
5852 }
5853
5854 return false;
5855}
5856} // namespace
5857
5858void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
5859 SourceLocation ColonLoc,
5860 ArrayRef<CXXCtorInitializer*> MemInits,
5861 bool AnyErrors) {
5862 if (!ConstructorDecl)
5863 return;
5864
5865 AdjustDeclIfTemplate(Decl&: ConstructorDecl);
5866
5867 CXXConstructorDecl *Constructor
5868 = dyn_cast<CXXConstructorDecl>(Val: ConstructorDecl);
5869
5870 if (!Constructor) {
5871 Diag(Loc: ColonLoc, DiagID: diag::err_only_constructors_take_base_inits);
5872 return;
5873 }
5874
5875 // Mapping for the duplicate initializers check.
5876 // For member initializers, this is keyed with a FieldDecl*.
5877 // For base initializers, this is keyed with a Type*.
5878 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5879
5880 // Mapping for the inconsistent anonymous-union initializers check.
5881 RedundantUnionMap MemberUnions;
5882
5883 bool HadError = false;
5884 for (unsigned i = 0; i < MemInits.size(); i++) {
5885 CXXCtorInitializer *Init = MemInits[i];
5886
5887 // Set the source order index.
5888 Init->setSourceOrder(i);
5889
5890 if (Init->isAnyMemberInitializer()) {
5891 const void *Key = GetKeyForMember(Context, Member: Init);
5892 if (CheckRedundantInit(S&: *this, Init, PrevInit&: Members[Key]) ||
5893 CheckRedundantUnionInit(S&: *this, Init, Unions&: MemberUnions))
5894 HadError = true;
5895 } else if (Init->isBaseInitializer()) {
5896 const void *Key = GetKeyForMember(Context, Member: Init);
5897 if (CheckRedundantInit(S&: *this, Init, PrevInit&: Members[Key]))
5898 HadError = true;
5899 } else {
5900 assert(Init->isDelegatingInitializer());
5901 // This must be the only initializer
5902 if (MemInits.size() != 1) {
5903 Diag(Loc: Init->getSourceLocation(),
5904 DiagID: diag::err_delegating_initializer_alone)
5905 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5906 // We will treat this as being the only initializer.
5907 }
5908 SetDelegatingInitializer(Constructor, Initializer: MemInits[i]);
5909 // Return immediately as the initializer is set.
5910 return;
5911 }
5912 }
5913
5914 if (HadError)
5915 return;
5916
5917 DiagnoseBaseOrMemInitializerOrder(SemaRef&: *this, Constructor, Inits: MemInits);
5918
5919 SetCtorInitializers(Constructor, AnyErrors, Initializers: MemInits);
5920
5921 DiagnoseUninitializedFields(SemaRef&: *this, Constructor);
5922}
5923
5924void Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,
5925 CXXRecordDecl *ClassDecl) {
5926 // Ignore dependent contexts. Also ignore unions, since their members never
5927 // have destructors implicitly called.
5928 if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
5929 return;
5930
5931 // FIXME: all the access-control diagnostics are positioned on the
5932 // field/base declaration. That's probably good; that said, the
5933 // user might reasonably want to know why the destructor is being
5934 // emitted, and we currently don't say.
5935
5936 // Non-static data members.
5937 for (auto *Field : ClassDecl->fields()) {
5938 MarkFieldDestructorReferenced(S&: *this, Location, Field);
5939 }
5940
5941 MarkBaseDestructorsReferenced(S&: *this, Location, ClassDecl);
5942}
5943
5944void Sema::MarkVirtualBaseDestructorsReferenced(
5945 SourceLocation Location, CXXRecordDecl *ClassDecl,
5946 llvm::SmallPtrSetImpl<const CXXRecordDecl *> *DirectVirtualBases) {
5947 // Virtual bases.
5948 for (const auto &VBase : ClassDecl->vbases()) {
5949 auto *BaseClassDecl = VBase.getType()->getAsCXXRecordDecl();
5950 if (!BaseClassDecl)
5951 continue;
5952
5953 // Ignore already visited direct virtual bases.
5954 if (DirectVirtualBases && DirectVirtualBases->count(Ptr: BaseClassDecl))
5955 continue;
5956
5957 auto *Dtor = LookupDestructorIfRelevant(S&: *this, Class: BaseClassDecl);
5958 if (!Dtor)
5959 continue;
5960
5961 CanQualType CT = Context.getCanonicalTagType(TD: ClassDecl);
5962 if (CheckDestructorAccess(Loc: ClassDecl->getLocation(), Dtor,
5963 PDiag: PDiag(DiagID: diag::err_access_dtor_vbase)
5964 << CT << VBase.getType(),
5965 objectType: CT) == AR_accessible) {
5966 CheckDerivedToBaseConversion(
5967 Derived: CT, Base: VBase.getType(), InaccessibleBaseID: diag::err_access_dtor_vbase, AmbiguousBaseConvID: 0,
5968 Loc: ClassDecl->getLocation(), Range: SourceRange(), Name: DeclarationName(), BasePath: nullptr);
5969 }
5970
5971 MarkFunctionReferenced(Loc: Location, Func: Dtor);
5972 DiagnoseUseOfDecl(D: Dtor, Locs: Location);
5973 }
5974}
5975
5976void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
5977 if (!CDtorDecl)
5978 return;
5979
5980 if (CXXConstructorDecl *Constructor
5981 = dyn_cast<CXXConstructorDecl>(Val: CDtorDecl)) {
5982 if (CXXRecordDecl *ClassDecl = Constructor->getParent();
5983 !ClassDecl || ClassDecl->isInvalidDecl()) {
5984 return;
5985 }
5986 SetCtorInitializers(Constructor, /*AnyErrors=*/false);
5987 DiagnoseUninitializedFields(SemaRef&: *this, Constructor);
5988 }
5989}
5990
5991bool Sema::isAbstractType(SourceLocation Loc, QualType T) {
5992 if (!getLangOpts().CPlusPlus)
5993 return false;
5994
5995 const auto *RD = Context.getBaseElementType(QT: T)->getAsCXXRecordDecl();
5996 if (!RD)
5997 return false;
5998
5999 // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
6000 // class template specialization here, but doing so breaks a lot of code.
6001
6002 // We can't answer whether something is abstract until it has a
6003 // definition. If it's currently being defined, we'll walk back
6004 // over all the declarations when we have a full definition.
6005 const CXXRecordDecl *Def = RD->getDefinition();
6006 if (!Def || Def->isBeingDefined())
6007 return false;
6008
6009 return RD->isAbstract();
6010}
6011
6012bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
6013 TypeDiagnoser &Diagnoser) {
6014 if (!isAbstractType(Loc, T))
6015 return false;
6016
6017 T = Context.getBaseElementType(QT: T);
6018 Diagnoser.diagnose(S&: *this, Loc, T);
6019 DiagnoseAbstractType(RD: T->getAsCXXRecordDecl());
6020 return true;
6021}
6022
6023void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
6024 // Check if we've already emitted the list of pure virtual functions
6025 // for this class.
6026 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(Ptr: RD))
6027 return;
6028
6029 // If the diagnostic is suppressed, don't emit the notes. We're only
6030 // going to emit them once, so try to attach them to a diagnostic we're
6031 // actually going to show.
6032 if (Diags.isLastDiagnosticIgnored())
6033 return;
6034
6035 CXXFinalOverriderMap FinalOverriders;
6036 RD->getFinalOverriders(FinaOverriders&: FinalOverriders);
6037
6038 // Keep a set of seen pure methods so we won't diagnose the same method
6039 // more than once.
6040 llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
6041
6042 for (const auto &M : FinalOverriders) {
6043 for (const auto &SO : M.second) {
6044 // C++ [class.abstract]p4:
6045 // A class is abstract if it contains or inherits at least one
6046 // pure virtual function for which the final overrider is pure
6047 // virtual.
6048
6049 if (SO.second.size() != 1)
6050 continue;
6051 const CXXMethodDecl *Method = SO.second.front().Method;
6052
6053 if (!Method->isPureVirtual())
6054 continue;
6055
6056 if (!SeenPureMethods.insert(Ptr: Method).second)
6057 continue;
6058
6059 Diag(Loc: Method->getLocation(), DiagID: diag::note_pure_virtual_function)
6060 << Method->getDeclName() << RD->getDeclName();
6061 }
6062 }
6063
6064 if (!PureVirtualClassDiagSet)
6065 PureVirtualClassDiagSet.reset(p: new RecordDeclSetTy);
6066 PureVirtualClassDiagSet->insert(Ptr: RD);
6067}
6068
6069namespace {
6070struct AbstractUsageInfo {
6071 Sema &S;
6072 CXXRecordDecl *Record;
6073 CanQualType AbstractType;
6074 bool Invalid;
6075
6076 AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
6077 : S(S), Record(Record),
6078 AbstractType(S.Context.getCanonicalTagType(TD: Record)), Invalid(false) {}
6079
6080 void DiagnoseAbstractType() {
6081 if (Invalid) return;
6082 S.DiagnoseAbstractType(RD: Record);
6083 Invalid = true;
6084 }
6085
6086 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
6087};
6088
6089struct CheckAbstractUsage {
6090 AbstractUsageInfo &Info;
6091 const NamedDecl *Ctx;
6092
6093 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
6094 : Info(Info), Ctx(Ctx) {}
6095
6096 void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
6097 switch (TL.getTypeLocClass()) {
6098#define ABSTRACT_TYPELOC(CLASS, PARENT)
6099#define TYPELOC(CLASS, PARENT) \
6100 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
6101#include "clang/AST/TypeLocNodes.def"
6102 }
6103 }
6104
6105 void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
6106 Visit(TL: TL.getReturnLoc(), Sel: Sema::AbstractReturnType);
6107 for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
6108 if (!TL.getParam(i: I))
6109 continue;
6110
6111 TypeSourceInfo *TSI = TL.getParam(i: I)->getTypeSourceInfo();
6112 if (TSI) Visit(TL: TSI->getTypeLoc(), Sel: Sema::AbstractParamType);
6113 }
6114 }
6115
6116 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
6117 Visit(TL: TL.getElementLoc(), Sel: Sema::AbstractArrayType);
6118 }
6119
6120 void Check(TemplateSpecializationTypeLoc TL, Sema::AbstractDiagSelID Sel) {
6121 // Visit the type parameters from a permissive context.
6122 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
6123 TemplateArgumentLoc TAL = TL.getArgLoc(i: I);
6124 if (TAL.getArgument().getKind() == TemplateArgument::Type)
6125 if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
6126 Visit(TL: TSI->getTypeLoc(), Sel: Sema::AbstractNone);
6127 // TODO: other template argument types?
6128 }
6129 }
6130
6131 // Visit pointee types from a permissive context.
6132#define CheckPolymorphic(Type) \
6133 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
6134 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
6135 }
6136 CheckPolymorphic(PointerTypeLoc)
6137 CheckPolymorphic(ReferenceTypeLoc)
6138 CheckPolymorphic(MemberPointerTypeLoc)
6139 CheckPolymorphic(BlockPointerTypeLoc)
6140 CheckPolymorphic(AtomicTypeLoc)
6141
6142 /// Handle all the types we haven't given a more specific
6143 /// implementation for above.
6144 void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
6145 // Every other kind of type that we haven't called out already
6146 // that has an inner type is either (1) sugar or (2) contains that
6147 // inner type in some way as a subobject.
6148 if (TypeLoc Next = TL.getNextTypeLoc())
6149 return Visit(TL: Next, Sel);
6150
6151 // If there's no inner type and we're in a permissive context,
6152 // don't diagnose.
6153 if (Sel == Sema::AbstractNone) return;
6154
6155 // Check whether the type matches the abstract type.
6156 QualType T = TL.getType();
6157 if (T->isArrayType()) {
6158 Sel = Sema::AbstractArrayType;
6159 T = Info.S.Context.getBaseElementType(QT: T);
6160 }
6161 CanQualType CT = T->getCanonicalTypeUnqualified();
6162 if (CT != Info.AbstractType) return;
6163
6164 // It matched; do some magic.
6165 // FIXME: These should be at most warnings. See P0929R2, CWG1640, CWG1646.
6166 if (Sel == Sema::AbstractArrayType) {
6167 Info.S.Diag(Loc: Ctx->getLocation(), DiagID: diag::err_array_of_abstract_type)
6168 << T << TL.getSourceRange();
6169 } else {
6170 Info.S.Diag(Loc: Ctx->getLocation(), DiagID: diag::err_abstract_type_in_decl)
6171 << Sel << T << TL.getSourceRange();
6172 }
6173 Info.DiagnoseAbstractType();
6174 }
6175};
6176
6177void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
6178 Sema::AbstractDiagSelID Sel) {
6179 CheckAbstractUsage(*this, D).Visit(TL, Sel);
6180}
6181
6182}
6183
6184/// Check for invalid uses of an abstract type in a function declaration.
6185static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6186 FunctionDecl *FD) {
6187 // Only definitions are required to refer to complete and
6188 // non-abstract types.
6189 if (!FD->doesThisDeclarationHaveABody())
6190 return;
6191
6192 // For safety's sake, just ignore it if we don't have type source
6193 // information. This should never happen for non-implicit methods,
6194 // but...
6195 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
6196 Info.CheckType(D: FD, TL: TSI->getTypeLoc(), Sel: Sema::AbstractNone);
6197}
6198
6199/// Check for invalid uses of an abstract type in a variable0 declaration.
6200static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6201 VarDecl *VD) {
6202 // No need to do the check on definitions, which require that
6203 // the type is complete.
6204 if (VD->isThisDeclarationADefinition())
6205 return;
6206
6207 Info.CheckType(D: VD, TL: VD->getTypeSourceInfo()->getTypeLoc(),
6208 Sel: Sema::AbstractVariableType);
6209}
6210
6211/// Check for invalid uses of an abstract type within a class definition.
6212static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6213 CXXRecordDecl *RD) {
6214 for (auto *D : RD->decls()) {
6215 if (D->isImplicit()) continue;
6216
6217 // Step through friends to the befriended declaration.
6218 if (auto *FD = dyn_cast<FriendDecl>(Val: D)) {
6219 D = FD->getFriendDecl();
6220 if (!D) continue;
6221 }
6222
6223 // Functions and function templates.
6224 if (auto *FD = dyn_cast<FunctionDecl>(Val: D)) {
6225 CheckAbstractClassUsage(Info, FD);
6226 } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Val: D)) {
6227 CheckAbstractClassUsage(Info, FD: FTD->getTemplatedDecl());
6228
6229 // Fields and static variables.
6230 } else if (auto *FD = dyn_cast<FieldDecl>(Val: D)) {
6231 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
6232 Info.CheckType(D: FD, TL: TSI->getTypeLoc(), Sel: Sema::AbstractFieldType);
6233 } else if (auto *VD = dyn_cast<VarDecl>(Val: D)) {
6234 CheckAbstractClassUsage(Info, VD);
6235 } else if (auto *VTD = dyn_cast<VarTemplateDecl>(Val: D)) {
6236 CheckAbstractClassUsage(Info, VD: VTD->getTemplatedDecl());
6237
6238 // Nested classes and class templates.
6239 } else if (auto *RD = dyn_cast<CXXRecordDecl>(Val: D)) {
6240 CheckAbstractClassUsage(Info, RD);
6241 } else if (auto *CTD = dyn_cast<ClassTemplateDecl>(Val: D)) {
6242 CheckAbstractClassUsage(Info, RD: CTD->getTemplatedDecl());
6243 }
6244 }
6245}
6246
6247static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class) {
6248 Attr *ClassAttr = getDLLAttr(D: Class);
6249 if (!ClassAttr)
6250 return;
6251
6252 assert(ClassAttr->getKind() == attr::DLLExport);
6253
6254 TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
6255
6256 if (TSK == TSK_ExplicitInstantiationDeclaration)
6257 // Don't go any further if this is just an explicit instantiation
6258 // declaration.
6259 return;
6260
6261 // Add a context note to explain how we got to any diagnostics produced below.
6262 struct MarkingClassDllexported {
6263 Sema &S;
6264 MarkingClassDllexported(Sema &S, CXXRecordDecl *Class,
6265 SourceLocation AttrLoc)
6266 : S(S) {
6267 Sema::CodeSynthesisContext Ctx;
6268 Ctx.Kind = Sema::CodeSynthesisContext::MarkingClassDllexported;
6269 Ctx.PointOfInstantiation = AttrLoc;
6270 Ctx.Entity = Class;
6271 S.pushCodeSynthesisContext(Ctx);
6272 }
6273 ~MarkingClassDllexported() {
6274 S.popCodeSynthesisContext();
6275 }
6276 } MarkingDllexportedContext(S, Class, ClassAttr->getLocation());
6277
6278 if (S.Context.getTargetInfo().getTriple().isOSCygMing())
6279 S.MarkVTableUsed(Loc: Class->getLocation(), Class, DefinitionRequired: true);
6280
6281 for (Decl *Member : Class->decls()) {
6282 // Skip members that were not marked exported.
6283 if (!Member->hasAttr<DLLExportAttr>())
6284 continue;
6285
6286 // Defined static variables that are members of an exported base
6287 // class must be marked export too.
6288 auto *VD = dyn_cast<VarDecl>(Val: Member);
6289 if (VD && VD->getStorageClass() == SC_Static &&
6290 TSK == TSK_ImplicitInstantiation)
6291 S.MarkVariableReferenced(Loc: VD->getLocation(), Var: VD);
6292
6293 auto *MD = dyn_cast<CXXMethodDecl>(Val: Member);
6294 if (!MD)
6295 continue;
6296
6297 if (MD->isUserProvided()) {
6298 // Instantiate non-default class member functions ...
6299
6300 // .. except for certain kinds of template specializations.
6301 if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
6302 continue;
6303
6304 // If this is an MS ABI dllexport default constructor, instantiate any
6305 // default arguments.
6306 if (S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
6307 auto *CD = dyn_cast<CXXConstructorDecl>(Val: MD);
6308 if (CD && CD->isDefaultConstructor() && TSK == TSK_Undeclared) {
6309 S.InstantiateDefaultCtorDefaultArgs(Ctor: CD);
6310 }
6311 }
6312
6313 S.MarkFunctionReferenced(Loc: Class->getLocation(), Func: MD);
6314
6315 // The function will be passed to the consumer when its definition is
6316 // encountered.
6317 } else if (MD->isExplicitlyDefaulted()) {
6318 // Synthesize and instantiate explicitly defaulted methods.
6319 S.MarkFunctionReferenced(Loc: Class->getLocation(), Func: MD);
6320
6321 if (TSK != TSK_ExplicitInstantiationDefinition) {
6322 // Except for explicit instantiation defs, we will not see the
6323 // definition again later, so pass it to the consumer now.
6324 S.Consumer.HandleTopLevelDecl(D: DeclGroupRef(MD));
6325 }
6326 } else if (!MD->isTrivial() ||
6327 MD->isCopyAssignmentOperator() ||
6328 MD->isMoveAssignmentOperator()) {
6329 // Synthesize and instantiate non-trivial implicit methods, and the copy
6330 // and move assignment operators. The latter are exported even if they
6331 // are trivial, because the address of an operator can be taken and
6332 // should compare equal across libraries.
6333 S.MarkFunctionReferenced(Loc: Class->getLocation(), Func: MD);
6334
6335 // There is no later point when we will see the definition of this
6336 // function, so pass it to the consumer now.
6337 S.Consumer.HandleTopLevelDecl(D: DeclGroupRef(MD));
6338 }
6339 }
6340}
6341
6342static void checkForMultipleExportedDefaultConstructors(Sema &S,
6343 CXXRecordDecl *Class) {
6344 // Only the MS ABI has default constructor closures, so we don't need to do
6345 // this semantic checking anywhere else.
6346 if (!S.Context.getTargetInfo().getCXXABI().isMicrosoft())
6347 return;
6348
6349 CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
6350 for (Decl *Member : Class->decls()) {
6351 // Look for exported default constructors.
6352 auto *CD = dyn_cast<CXXConstructorDecl>(Val: Member);
6353 if (!CD || !CD->isDefaultConstructor())
6354 continue;
6355 auto *Attr = CD->getAttr<DLLExportAttr>();
6356 if (!Attr)
6357 continue;
6358
6359 // If the class is non-dependent, mark the default arguments as ODR-used so
6360 // that we can properly codegen the constructor closure.
6361 if (!Class->isDependentContext()) {
6362 for (ParmVarDecl *PD : CD->parameters()) {
6363 (void)S.CheckCXXDefaultArgExpr(CallLoc: Attr->getLocation(), FD: CD, Param: PD);
6364 S.DiscardCleanupsInEvaluationContext();
6365 }
6366 }
6367
6368 if (LastExportedDefaultCtor) {
6369 S.Diag(Loc: LastExportedDefaultCtor->getLocation(),
6370 DiagID: diag::err_attribute_dll_ambiguous_default_ctor)
6371 << Class;
6372 S.Diag(Loc: CD->getLocation(), DiagID: diag::note_entity_declared_at)
6373 << CD->getDeclName();
6374 return;
6375 }
6376 LastExportedDefaultCtor = CD;
6377 }
6378}
6379
6380static void checkCUDADeviceBuiltinSurfaceClassTemplate(Sema &S,
6381 CXXRecordDecl *Class) {
6382 bool ErrorReported = false;
6383 auto reportIllegalClassTemplate = [&ErrorReported](Sema &S,
6384 ClassTemplateDecl *TD) {
6385 if (ErrorReported)
6386 return;
6387 S.Diag(Loc: TD->getLocation(),
6388 DiagID: diag::err_cuda_device_builtin_surftex_cls_template)
6389 << /*surface*/ 0 << TD;
6390 ErrorReported = true;
6391 };
6392
6393 ClassTemplateDecl *TD = Class->getDescribedClassTemplate();
6394 if (!TD) {
6395 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(Val: Class);
6396 if (!SD) {
6397 S.Diag(Loc: Class->getLocation(),
6398 DiagID: diag::err_cuda_device_builtin_surftex_ref_decl)
6399 << /*surface*/ 0 << Class;
6400 S.Diag(Loc: Class->getLocation(),
6401 DiagID: diag::note_cuda_device_builtin_surftex_should_be_template_class)
6402 << Class;
6403 return;
6404 }
6405 TD = SD->getSpecializedTemplate();
6406 }
6407
6408 TemplateParameterList *Params = TD->getTemplateParameters();
6409 unsigned N = Params->size();
6410
6411 if (N != 2) {
6412 reportIllegalClassTemplate(S, TD);
6413 S.Diag(Loc: TD->getLocation(),
6414 DiagID: diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6415 << TD << 2;
6416 }
6417 if (N > 0 && !isa<TemplateTypeParmDecl>(Val: Params->getParam(Idx: 0))) {
6418 reportIllegalClassTemplate(S, TD);
6419 S.Diag(Loc: TD->getLocation(),
6420 DiagID: diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6421 << TD << /*1st*/ 0 << /*type*/ 0;
6422 }
6423 if (N > 1) {
6424 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: Params->getParam(Idx: 1));
6425 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6426 reportIllegalClassTemplate(S, TD);
6427 S.Diag(Loc: TD->getLocation(),
6428 DiagID: diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6429 << TD << /*2nd*/ 1 << /*integer*/ 1;
6430 }
6431 }
6432}
6433
6434static void checkCUDADeviceBuiltinTextureClassTemplate(Sema &S,
6435 CXXRecordDecl *Class) {
6436 bool ErrorReported = false;
6437 auto reportIllegalClassTemplate = [&ErrorReported](Sema &S,
6438 ClassTemplateDecl *TD) {
6439 if (ErrorReported)
6440 return;
6441 S.Diag(Loc: TD->getLocation(),
6442 DiagID: diag::err_cuda_device_builtin_surftex_cls_template)
6443 << /*texture*/ 1 << TD;
6444 ErrorReported = true;
6445 };
6446
6447 ClassTemplateDecl *TD = Class->getDescribedClassTemplate();
6448 if (!TD) {
6449 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(Val: Class);
6450 if (!SD) {
6451 S.Diag(Loc: Class->getLocation(),
6452 DiagID: diag::err_cuda_device_builtin_surftex_ref_decl)
6453 << /*texture*/ 1 << Class;
6454 S.Diag(Loc: Class->getLocation(),
6455 DiagID: diag::note_cuda_device_builtin_surftex_should_be_template_class)
6456 << Class;
6457 return;
6458 }
6459 TD = SD->getSpecializedTemplate();
6460 }
6461
6462 TemplateParameterList *Params = TD->getTemplateParameters();
6463 unsigned N = Params->size();
6464
6465 if (N != 3) {
6466 reportIllegalClassTemplate(S, TD);
6467 S.Diag(Loc: TD->getLocation(),
6468 DiagID: diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6469 << TD << 3;
6470 }
6471 if (N > 0 && !isa<TemplateTypeParmDecl>(Val: Params->getParam(Idx: 0))) {
6472 reportIllegalClassTemplate(S, TD);
6473 S.Diag(Loc: TD->getLocation(),
6474 DiagID: diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6475 << TD << /*1st*/ 0 << /*type*/ 0;
6476 }
6477 if (N > 1) {
6478 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: Params->getParam(Idx: 1));
6479 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6480 reportIllegalClassTemplate(S, TD);
6481 S.Diag(Loc: TD->getLocation(),
6482 DiagID: diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6483 << TD << /*2nd*/ 1 << /*integer*/ 1;
6484 }
6485 }
6486 if (N > 2) {
6487 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: Params->getParam(Idx: 2));
6488 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6489 reportIllegalClassTemplate(S, TD);
6490 S.Diag(Loc: TD->getLocation(),
6491 DiagID: diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6492 << TD << /*3rd*/ 2 << /*integer*/ 1;
6493 }
6494 }
6495}
6496
6497void Sema::checkClassLevelCodeSegAttribute(CXXRecordDecl *Class) {
6498 // Mark any compiler-generated routines with the implicit code_seg attribute.
6499 for (auto *Method : Class->methods()) {
6500 if (Method->isUserProvided())
6501 continue;
6502 if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(FD: Method, /*IsDefinition=*/true))
6503 Method->addAttr(A);
6504 }
6505}
6506
6507void Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) {
6508 Attr *ClassAttr = getDLLAttr(D: Class);
6509
6510 // MSVC inherits DLL attributes to partial class template specializations.
6511 if (Context.getTargetInfo().shouldDLLImportComdatSymbols() && !ClassAttr) {
6512 if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Val: Class)) {
6513 if (Attr *TemplateAttr =
6514 getDLLAttr(D: Spec->getSpecializedTemplate()->getTemplatedDecl())) {
6515 auto *A = cast<InheritableAttr>(Val: TemplateAttr->clone(C&: getASTContext()));
6516 A->setInherited(true);
6517 ClassAttr = A;
6518 }
6519 }
6520 }
6521
6522 if (!ClassAttr)
6523 return;
6524
6525 // MSVC allows imported or exported template classes that have UniqueExternal
6526 // linkage. This occurs when the template class has been instantiated with
6527 // a template parameter which itself has internal linkage.
6528 // We drop the attribute to avoid exporting or importing any members.
6529 if ((Context.getTargetInfo().getCXXABI().isMicrosoft() ||
6530 Context.getTargetInfo().getTriple().isPS()) &&
6531 (!Class->isExternallyVisible() && Class->hasExternalFormalLinkage())) {
6532 Class->dropAttrs<DLLExportAttr, DLLImportAttr>();
6533 return;
6534 }
6535
6536 if (!Class->isExternallyVisible()) {
6537 Diag(Loc: Class->getLocation(), DiagID: diag::err_attribute_dll_not_extern)
6538 << Class << ClassAttr;
6539 return;
6540 }
6541
6542 if (Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
6543 !ClassAttr->isInherited()) {
6544 // Diagnose dll attributes on members of class with dll attribute.
6545 for (Decl *Member : Class->decls()) {
6546 if (!isa<VarDecl>(Val: Member) && !isa<CXXMethodDecl>(Val: Member))
6547 continue;
6548 InheritableAttr *MemberAttr = getDLLAttr(D: Member);
6549 if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
6550 continue;
6551
6552 Diag(Loc: MemberAttr->getLocation(),
6553 DiagID: diag::err_attribute_dll_member_of_dll_class)
6554 << MemberAttr << ClassAttr;
6555 Diag(Loc: ClassAttr->getLocation(), DiagID: diag::note_previous_attribute);
6556 Member->setInvalidDecl();
6557 }
6558 }
6559
6560 if (Class->getDescribedClassTemplate())
6561 // Don't inherit dll attribute until the template is instantiated.
6562 return;
6563
6564 // The class is either imported or exported.
6565 const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
6566
6567 // Check if this was a dllimport attribute propagated from a derived class to
6568 // a base class template specialization. We don't apply these attributes to
6569 // static data members.
6570 const bool PropagatedImport =
6571 !ClassExported &&
6572 cast<DLLImportAttr>(Val: ClassAttr)->wasPropagatedToBaseTemplate();
6573
6574 TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
6575
6576 // Ignore explicit dllexport on explicit class template instantiation
6577 // declarations, except in MinGW mode.
6578 if (ClassExported && !ClassAttr->isInherited() &&
6579 TSK == TSK_ExplicitInstantiationDeclaration &&
6580 !Context.getTargetInfo().getTriple().isOSCygMing()) {
6581 if (auto *DEA = Class->getAttr<DLLExportAttr>()) {
6582 Class->addAttr(A: DLLExportOnDeclAttr::Create(Ctx&: Context, Range: DEA->getLoc()));
6583 Class->dropAttr<DLLExportAttr>();
6584 }
6585 return;
6586 }
6587
6588 // Force declaration of implicit members so they can inherit the attribute.
6589 ForceDeclarationOfImplicitMembers(Class);
6590
6591 // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
6592 // seem to be true in practice?
6593
6594 for (Decl *Member : Class->decls()) {
6595 VarDecl *VD = dyn_cast<VarDecl>(Val: Member);
6596 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: Member);
6597
6598 // Only methods and static fields inherit the attributes.
6599 if (!VD && !MD)
6600 continue;
6601
6602 if (MD) {
6603 // Don't process deleted methods.
6604 if (MD->isDeleted())
6605 continue;
6606
6607 if (MD->isInlined()) {
6608 // MinGW does not import or export inline methods. But do it for
6609 // template instantiations.
6610 if (!Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
6611 TSK != TSK_ExplicitInstantiationDeclaration &&
6612 TSK != TSK_ExplicitInstantiationDefinition)
6613 continue;
6614
6615 // MSVC versions before 2015 don't export the move assignment operators
6616 // and move constructor, so don't attempt to import/export them if
6617 // we have a definition.
6618 auto *Ctor = dyn_cast<CXXConstructorDecl>(Val: MD);
6619 if ((MD->isMoveAssignmentOperator() ||
6620 (Ctor && Ctor->isMoveConstructor())) &&
6621 getLangOpts().isCompatibleWithMSVC() &&
6622 !getLangOpts().isCompatibleWithMSVC(MajorVersion: LangOptions::MSVC2015))
6623 continue;
6624
6625 // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
6626 // operator is exported anyway.
6627 if (getLangOpts().isCompatibleWithMSVC(MajorVersion: LangOptions::MSVC2015) &&
6628 (Ctor || isa<CXXDestructorDecl>(Val: MD)) && MD->isTrivial())
6629 continue;
6630 }
6631 }
6632
6633 // Don't apply dllimport attributes to static data members of class template
6634 // instantiations when the attribute is propagated from a derived class.
6635 if (VD && PropagatedImport)
6636 continue;
6637
6638 if (!cast<NamedDecl>(Val: Member)->isExternallyVisible())
6639 continue;
6640
6641 if (!getDLLAttr(D: Member)) {
6642 InheritableAttr *NewAttr = nullptr;
6643
6644 // Do not export/import inline function when -fno-dllexport-inlines is
6645 // passed. But add attribute for later local static var check.
6646 if (!getLangOpts().DllExportInlines && MD && MD->isInlined() &&
6647 TSK != TSK_ExplicitInstantiationDeclaration &&
6648 TSK != TSK_ExplicitInstantiationDefinition) {
6649 if (ClassExported) {
6650 NewAttr = ::new (getASTContext())
6651 DLLExportStaticLocalAttr(getASTContext(), *ClassAttr);
6652 } else {
6653 NewAttr = ::new (getASTContext())
6654 DLLImportStaticLocalAttr(getASTContext(), *ClassAttr);
6655 }
6656 } else {
6657 NewAttr = cast<InheritableAttr>(Val: ClassAttr->clone(C&: getASTContext()));
6658 }
6659
6660 NewAttr->setInherited(true);
6661 Member->addAttr(A: NewAttr);
6662
6663 if (MD) {
6664 // Propagate DLLAttr to friend re-declarations of MD that have already
6665 // been constructed.
6666 for (FunctionDecl *FD = MD->getMostRecentDecl(); FD;
6667 FD = FD->getPreviousDecl()) {
6668 if (FD->getFriendObjectKind() == Decl::FOK_None)
6669 continue;
6670 assert(!getDLLAttr(FD) &&
6671 "friend re-decl should not already have a DLLAttr");
6672 NewAttr = cast<InheritableAttr>(Val: ClassAttr->clone(C&: getASTContext()));
6673 NewAttr->setInherited(true);
6674 FD->addAttr(A: NewAttr);
6675 }
6676 }
6677 }
6678 }
6679
6680 if (ClassExported)
6681 DelayedDllExportClasses.push_back(Elt: Class);
6682}
6683
6684void Sema::propagateDLLAttrToBaseClassTemplate(
6685 CXXRecordDecl *Class, Attr *ClassAttr,
6686 ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
6687 if (getDLLAttr(
6688 D: BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
6689 // If the base class template has a DLL attribute, don't try to change it.
6690 return;
6691 }
6692
6693 auto TSK = BaseTemplateSpec->getSpecializationKind();
6694 if (!getDLLAttr(D: BaseTemplateSpec) &&
6695 (TSK == TSK_Undeclared || TSK == TSK_ExplicitInstantiationDeclaration ||
6696 TSK == TSK_ImplicitInstantiation)) {
6697 // The template hasn't been instantiated yet (or it has, but only as an
6698 // explicit instantiation declaration or implicit instantiation, which means
6699 // we haven't codegenned any members yet), so propagate the attribute.
6700 auto *NewAttr = cast<InheritableAttr>(Val: ClassAttr->clone(C&: getASTContext()));
6701 NewAttr->setInherited(true);
6702 BaseTemplateSpec->addAttr(A: NewAttr);
6703
6704 // If this was an import, mark that we propagated it from a derived class to
6705 // a base class template specialization.
6706 if (auto *ImportAttr = dyn_cast<DLLImportAttr>(Val: NewAttr))
6707 ImportAttr->setPropagatedToBaseTemplate();
6708
6709 // If the template is already instantiated, checkDLLAttributeRedeclaration()
6710 // needs to be run again to work see the new attribute. Otherwise this will
6711 // get run whenever the template is instantiated.
6712 if (TSK != TSK_Undeclared)
6713 checkClassLevelDLLAttribute(Class: BaseTemplateSpec);
6714
6715 return;
6716 }
6717
6718 if (getDLLAttr(D: BaseTemplateSpec)) {
6719 // The template has already been specialized or instantiated with an
6720 // attribute, explicitly or through propagation. We should not try to change
6721 // it.
6722 return;
6723 }
6724
6725 // The template was previously instantiated or explicitly specialized without
6726 // a dll attribute, It's too late for us to add an attribute, so warn that
6727 // this is unsupported.
6728 Diag(Loc: BaseLoc, DiagID: diag::warn_attribute_dll_instantiated_base_class)
6729 << BaseTemplateSpec->isExplicitSpecialization();
6730 Diag(Loc: ClassAttr->getLocation(), DiagID: diag::note_attribute);
6731 if (BaseTemplateSpec->isExplicitSpecialization()) {
6732 Diag(Loc: BaseTemplateSpec->getLocation(),
6733 DiagID: diag::note_template_class_explicit_specialization_was_here)
6734 << BaseTemplateSpec;
6735 } else {
6736 Diag(Loc: BaseTemplateSpec->getPointOfInstantiation(),
6737 DiagID: diag::note_template_class_instantiation_was_here)
6738 << BaseTemplateSpec;
6739 }
6740}
6741
6742Sema::DefaultedFunctionKind
6743Sema::getDefaultedFunctionKind(const FunctionDecl *FD) {
6744 if (auto *MD = dyn_cast<CXXMethodDecl>(Val: FD)) {
6745 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Val: FD)) {
6746 if (Ctor->isDefaultConstructor())
6747 return CXXSpecialMemberKind::DefaultConstructor;
6748
6749 if (Ctor->isCopyConstructor())
6750 return CXXSpecialMemberKind::CopyConstructor;
6751
6752 if (Ctor->isMoveConstructor())
6753 return CXXSpecialMemberKind::MoveConstructor;
6754 }
6755
6756 if (MD->isCopyAssignmentOperator())
6757 return CXXSpecialMemberKind::CopyAssignment;
6758
6759 if (MD->isMoveAssignmentOperator())
6760 return CXXSpecialMemberKind::MoveAssignment;
6761
6762 if (isa<CXXDestructorDecl>(Val: FD))
6763 return CXXSpecialMemberKind::Destructor;
6764 }
6765
6766 switch (FD->getDeclName().getCXXOverloadedOperator()) {
6767 case OO_EqualEqual:
6768 return DefaultedComparisonKind::Equal;
6769
6770 case OO_ExclaimEqual:
6771 return DefaultedComparisonKind::NotEqual;
6772
6773 case OO_Spaceship:
6774 // No point allowing this if <=> doesn't exist in the current language mode.
6775 if (!getLangOpts().CPlusPlus20)
6776 break;
6777 return DefaultedComparisonKind::ThreeWay;
6778
6779 case OO_Less:
6780 case OO_LessEqual:
6781 case OO_Greater:
6782 case OO_GreaterEqual:
6783 // No point allowing this if <=> doesn't exist in the current language mode.
6784 if (!getLangOpts().CPlusPlus20)
6785 break;
6786 return DefaultedComparisonKind::Relational;
6787
6788 default:
6789 break;
6790 }
6791
6792 // Not defaultable.
6793 return DefaultedFunctionKind();
6794}
6795
6796static void DefineDefaultedFunction(Sema &S, FunctionDecl *FD,
6797 SourceLocation DefaultLoc) {
6798 Sema::DefaultedFunctionKind DFK = S.getDefaultedFunctionKind(FD);
6799 if (DFK.isComparison())
6800 return S.DefineDefaultedComparison(Loc: DefaultLoc, FD, DCK: DFK.asComparison());
6801
6802 switch (DFK.asSpecialMember()) {
6803 case CXXSpecialMemberKind::DefaultConstructor:
6804 S.DefineImplicitDefaultConstructor(CurrentLocation: DefaultLoc,
6805 Constructor: cast<CXXConstructorDecl>(Val: FD));
6806 break;
6807 case CXXSpecialMemberKind::CopyConstructor:
6808 S.DefineImplicitCopyConstructor(CurrentLocation: DefaultLoc, Constructor: cast<CXXConstructorDecl>(Val: FD));
6809 break;
6810 case CXXSpecialMemberKind::CopyAssignment:
6811 S.DefineImplicitCopyAssignment(CurrentLocation: DefaultLoc, MethodDecl: cast<CXXMethodDecl>(Val: FD));
6812 break;
6813 case CXXSpecialMemberKind::Destructor:
6814 S.DefineImplicitDestructor(CurrentLocation: DefaultLoc, Destructor: cast<CXXDestructorDecl>(Val: FD));
6815 break;
6816 case CXXSpecialMemberKind::MoveConstructor:
6817 S.DefineImplicitMoveConstructor(CurrentLocation: DefaultLoc, Constructor: cast<CXXConstructorDecl>(Val: FD));
6818 break;
6819 case CXXSpecialMemberKind::MoveAssignment:
6820 S.DefineImplicitMoveAssignment(CurrentLocation: DefaultLoc, MethodDecl: cast<CXXMethodDecl>(Val: FD));
6821 break;
6822 case CXXSpecialMemberKind::Invalid:
6823 llvm_unreachable("Invalid special member.");
6824 }
6825}
6826
6827/// Determine whether a type is permitted to be passed or returned in
6828/// registers, per C++ [class.temporary]p3.
6829static bool canPassInRegisters(Sema &S, CXXRecordDecl *D,
6830 TargetInfo::CallingConvKind CCK) {
6831 if (D->isDependentType() || D->isInvalidDecl())
6832 return false;
6833
6834 // Clang <= 4 used the pre-C++11 rule, which ignores move operations.
6835 // The PS4 platform ABI follows the behavior of Clang 3.2.
6836 if (CCK == TargetInfo::CCK_ClangABI4OrPS4)
6837 return !D->hasNonTrivialDestructorForCall() &&
6838 !D->hasNonTrivialCopyConstructorForCall();
6839
6840 if (CCK == TargetInfo::CCK_MicrosoftWin64) {
6841 bool CopyCtorIsTrivial = false, CopyCtorIsTrivialForCall = false;
6842 bool DtorIsTrivialForCall = false;
6843
6844 // If a class has at least one eligible, trivial copy constructor, it
6845 // is passed according to the C ABI. Otherwise, it is passed indirectly.
6846 //
6847 // Note: This permits classes with non-trivial copy or move ctors to be
6848 // passed in registers, so long as they *also* have a trivial copy ctor,
6849 // which is non-conforming.
6850 if (D->needsImplicitCopyConstructor()) {
6851 if (!D->defaultedCopyConstructorIsDeleted()) {
6852 if (D->hasTrivialCopyConstructor())
6853 CopyCtorIsTrivial = true;
6854 if (D->hasTrivialCopyConstructorForCall())
6855 CopyCtorIsTrivialForCall = true;
6856 }
6857 } else {
6858 for (const CXXConstructorDecl *CD : D->ctors()) {
6859 if (CD->isCopyConstructor() && !CD->isDeleted() &&
6860 !CD->isIneligibleOrNotSelected()) {
6861 if (CD->isTrivial())
6862 CopyCtorIsTrivial = true;
6863 if (CD->isTrivialForCall())
6864 CopyCtorIsTrivialForCall = true;
6865 }
6866 }
6867 }
6868
6869 if (D->needsImplicitDestructor()) {
6870 if (!D->defaultedDestructorIsDeleted() &&
6871 D->hasTrivialDestructorForCall())
6872 DtorIsTrivialForCall = true;
6873 } else if (const auto *DD = D->getDestructor()) {
6874 if (!DD->isDeleted() && DD->isTrivialForCall())
6875 DtorIsTrivialForCall = true;
6876 }
6877
6878 // If the copy ctor and dtor are both trivial-for-calls, pass direct.
6879 if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6880 return true;
6881
6882 // If a class has a destructor, we'd really like to pass it indirectly
6883 // because it allows us to elide copies. Unfortunately, MSVC makes that
6884 // impossible for small types, which it will pass in a single register or
6885 // stack slot. Most objects with dtors are large-ish, so handle that early.
6886 // We can't call out all large objects as being indirect because there are
6887 // multiple x64 calling conventions and the C++ ABI code shouldn't dictate
6888 // how we pass large POD types.
6889
6890 // Note: This permits small classes with nontrivial destructors to be
6891 // passed in registers, which is non-conforming.
6892 bool isAArch64 = S.Context.getTargetInfo().getTriple().isAArch64();
6893 uint64_t TypeSize = isAArch64 ? 128 : 64;
6894
6895 if (CopyCtorIsTrivial && S.getASTContext().getTypeSize(
6896 T: S.Context.getCanonicalTagType(TD: D)) <= TypeSize)
6897 return true;
6898 return false;
6899 }
6900
6901 // Per C++ [class.temporary]p3, the relevant condition is:
6902 // each copy constructor, move constructor, and destructor of X is
6903 // either trivial or deleted, and X has at least one non-deleted copy
6904 // or move constructor
6905 bool HasNonDeletedCopyOrMove = false;
6906
6907 if (D->needsImplicitCopyConstructor() &&
6908 !D->defaultedCopyConstructorIsDeleted()) {
6909 if (!D->hasTrivialCopyConstructorForCall())
6910 return false;
6911 HasNonDeletedCopyOrMove = true;
6912 }
6913
6914 if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor() &&
6915 !D->defaultedMoveConstructorIsDeleted()) {
6916 if (!D->hasTrivialMoveConstructorForCall())
6917 return false;
6918 HasNonDeletedCopyOrMove = true;
6919 }
6920
6921 if (D->needsImplicitDestructor() && !D->defaultedDestructorIsDeleted() &&
6922 !D->hasTrivialDestructorForCall())
6923 return false;
6924
6925 for (const CXXMethodDecl *MD : D->methods()) {
6926 if (MD->isDeleted() || MD->isIneligibleOrNotSelected())
6927 continue;
6928
6929 auto *CD = dyn_cast<CXXConstructorDecl>(Val: MD);
6930 if (CD && CD->isCopyOrMoveConstructor())
6931 HasNonDeletedCopyOrMove = true;
6932 else if (!isa<CXXDestructorDecl>(Val: MD))
6933 continue;
6934
6935 if (!MD->isTrivialForCall())
6936 return false;
6937 }
6938
6939 return HasNonDeletedCopyOrMove;
6940}
6941
6942/// Report an error regarding overriding, along with any relevant
6943/// overridden methods.
6944///
6945/// \param DiagID the primary error to report.
6946/// \param MD the overriding method.
6947static bool
6948ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD,
6949 llvm::function_ref<bool(const CXXMethodDecl *)> Report) {
6950 bool IssuedDiagnostic = false;
6951 for (const CXXMethodDecl *O : MD->overridden_methods()) {
6952 if (Report(O)) {
6953 if (!IssuedDiagnostic) {
6954 S.Diag(Loc: MD->getLocation(), DiagID) << MD->getDeclName();
6955 IssuedDiagnostic = true;
6956 }
6957 S.Diag(Loc: O->getLocation(), DiagID: diag::note_overridden_virtual_function);
6958 }
6959 }
6960 return IssuedDiagnostic;
6961}
6962
6963void Sema::CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record) {
6964 if (!Record)
6965 return;
6966
6967 if (Record->isAbstract() && !Record->isInvalidDecl()) {
6968 AbstractUsageInfo Info(*this, Record);
6969 CheckAbstractClassUsage(Info, RD: Record);
6970 }
6971
6972 // If this is not an aggregate type and has no user-declared constructor,
6973 // complain about any non-static data members of reference or const scalar
6974 // type, since they will never get initializers.
6975 if (!Record->isInvalidDecl() && !Record->isDependentType() &&
6976 !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
6977 !Record->isLambda()) {
6978 bool Complained = false;
6979 for (const auto *F : Record->fields()) {
6980 if (F->hasInClassInitializer() || F->isUnnamedBitField())
6981 continue;
6982
6983 if (F->getType()->isReferenceType() ||
6984 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
6985 if (!Complained) {
6986 Diag(Loc: Record->getLocation(), DiagID: diag::warn_no_constructor_for_refconst)
6987 << Record->getTagKind() << Record;
6988 Complained = true;
6989 }
6990
6991 Diag(Loc: F->getLocation(), DiagID: diag::note_refconst_member_not_initialized)
6992 << F->getType()->isReferenceType()
6993 << F->getDeclName();
6994 }
6995 }
6996 }
6997
6998 if (Record->getIdentifier()) {
6999 // C++ [class.mem]p13:
7000 // If T is the name of a class, then each of the following shall have a
7001 // name different from T:
7002 // - every member of every anonymous union that is a member of class T.
7003 //
7004 // C++ [class.mem]p14:
7005 // In addition, if class T has a user-declared constructor (12.1), every
7006 // non-static data member of class T shall have a name different from T.
7007 for (const NamedDecl *Element : Record->lookup(Name: Record->getDeclName())) {
7008 const NamedDecl *D = Element->getUnderlyingDecl();
7009 // Invalid IndirectFieldDecls have already been diagnosed with
7010 // err_anonymous_record_member_redecl in
7011 // SemaDecl.cpp:CheckAnonMemberRedeclaration.
7012 if (((isa<FieldDecl>(Val: D) || isa<UnresolvedUsingValueDecl>(Val: D)) &&
7013 Record->hasUserDeclaredConstructor()) ||
7014 (isa<IndirectFieldDecl>(Val: D) && !D->isInvalidDecl())) {
7015 Diag(Loc: Element->getLocation(), DiagID: diag::err_member_name_of_class)
7016 << D->getDeclName();
7017 break;
7018 }
7019 }
7020 }
7021
7022 // Warn if the class has virtual methods but non-virtual public destructor.
7023 if (Record->isPolymorphic() && !Record->isDependentType()) {
7024 CXXDestructorDecl *dtor = Record->getDestructor();
7025 if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
7026 !Record->hasAttr<FinalAttr>())
7027 Diag(Loc: dtor ? dtor->getLocation() : Record->getLocation(),
7028 DiagID: diag::warn_non_virtual_dtor)
7029 << Context.getCanonicalTagType(TD: Record);
7030 }
7031
7032 if (Record->isAbstract()) {
7033 if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
7034 Diag(Loc: Record->getLocation(), DiagID: diag::warn_abstract_final_class)
7035 << FA->isSpelledAsSealed();
7036 DiagnoseAbstractType(RD: Record);
7037 }
7038 }
7039
7040 // Warn if the class has a final destructor but is not itself marked final.
7041 if (!Record->hasAttr<FinalAttr>()) {
7042 if (const CXXDestructorDecl *dtor = Record->getDestructor()) {
7043 if (const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
7044 Diag(Loc: FA->getLocation(), DiagID: diag::warn_final_dtor_non_final_class)
7045 << FA->isSpelledAsSealed()
7046 << FixItHint::CreateInsertion(
7047 InsertionLoc: getLocForEndOfToken(Loc: Record->getLocation()),
7048 Code: (FA->isSpelledAsSealed() ? " sealed" : " final"));
7049 Diag(Loc: Record->getLocation(),
7050 DiagID: diag::note_final_dtor_non_final_class_silence)
7051 << Context.getCanonicalTagType(TD: Record) << FA->isSpelledAsSealed();
7052 }
7053 }
7054 }
7055
7056 // See if trivial_abi has to be dropped.
7057 if (Record->hasAttr<TrivialABIAttr>())
7058 checkIllFormedTrivialABIStruct(RD&: *Record);
7059
7060 // Set HasTrivialSpecialMemberForCall if the record has attribute
7061 // "trivial_abi".
7062 bool HasTrivialABI = Record->hasAttr<TrivialABIAttr>();
7063
7064 if (HasTrivialABI)
7065 Record->setHasTrivialSpecialMemberForCall();
7066
7067 // Explicitly-defaulted secondary comparison functions (!=, <, <=, >, >=).
7068 // We check these last because they can depend on the properties of the
7069 // primary comparison functions (==, <=>).
7070 llvm::SmallVector<FunctionDecl*, 5> DefaultedSecondaryComparisons;
7071
7072 // Perform checks that can't be done until we know all the properties of a
7073 // member function (whether it's defaulted, deleted, virtual, overriding,
7074 // ...).
7075 auto CheckCompletedMemberFunction = [&](CXXMethodDecl *MD) {
7076 // A static function cannot override anything.
7077 if (MD->getStorageClass() == SC_Static) {
7078 if (ReportOverrides(S&: *this, DiagID: diag::err_static_overrides_virtual, MD,
7079 Report: [](const CXXMethodDecl *) { return true; }))
7080 return;
7081 }
7082
7083 // A deleted function cannot override a non-deleted function and vice
7084 // versa.
7085 if (ReportOverrides(S&: *this,
7086 DiagID: MD->isDeleted() ? diag::err_deleted_override
7087 : diag::err_non_deleted_override,
7088 MD, Report: [&](const CXXMethodDecl *V) {
7089 return MD->isDeleted() != V->isDeleted();
7090 })) {
7091 if (MD->isDefaulted() && MD->isDeleted())
7092 // Explain why this defaulted function was deleted.
7093 DiagnoseDeletedDefaultedFunction(FD: MD);
7094 return;
7095 }
7096
7097 // A consteval function cannot override a non-consteval function and vice
7098 // versa.
7099 if (ReportOverrides(S&: *this,
7100 DiagID: MD->isConsteval() ? diag::err_consteval_override
7101 : diag::err_non_consteval_override,
7102 MD, Report: [&](const CXXMethodDecl *V) {
7103 return MD->isConsteval() != V->isConsteval();
7104 })) {
7105 if (MD->isDefaulted() && MD->isDeleted())
7106 // Explain why this defaulted function was deleted.
7107 DiagnoseDeletedDefaultedFunction(FD: MD);
7108 return;
7109 }
7110 };
7111
7112 auto CheckForDefaultedFunction = [&](FunctionDecl *FD) -> bool {
7113 if (!FD || FD->isInvalidDecl() || !FD->isExplicitlyDefaulted())
7114 return false;
7115
7116 DefaultedFunctionKind DFK = getDefaultedFunctionKind(FD);
7117 if (DFK.asComparison() == DefaultedComparisonKind::NotEqual ||
7118 DFK.asComparison() == DefaultedComparisonKind::Relational) {
7119 DefaultedSecondaryComparisons.push_back(Elt: FD);
7120 return true;
7121 }
7122
7123 CheckExplicitlyDefaultedFunction(S, MD: FD);
7124 return false;
7125 };
7126
7127 if (!Record->isInvalidDecl() &&
7128 Record->hasAttr<VTablePointerAuthenticationAttr>())
7129 checkIncorrectVTablePointerAuthenticationAttribute(RD&: *Record);
7130
7131 auto CompleteMemberFunction = [&](CXXMethodDecl *M) {
7132 // Check whether the explicitly-defaulted members are valid.
7133 bool Incomplete = CheckForDefaultedFunction(M);
7134
7135 // Skip the rest of the checks for a member of a dependent class.
7136 if (Record->isDependentType())
7137 return;
7138
7139 // For an explicitly defaulted or deleted special member, we defer
7140 // determining triviality until the class is complete. That time is now!
7141 CXXSpecialMemberKind CSM = getSpecialMember(MD: M);
7142 if (!M->isImplicit() && !M->isUserProvided()) {
7143 if (CSM != CXXSpecialMemberKind::Invalid) {
7144 M->setTrivial(SpecialMemberIsTrivial(MD: M, CSM));
7145 // Inform the class that we've finished declaring this member.
7146 Record->finishedDefaultedOrDeletedMember(MD: M);
7147 M->setTrivialForCall(
7148 HasTrivialABI ||
7149 SpecialMemberIsTrivial(MD: M, CSM,
7150 TAH: TrivialABIHandling::ConsiderTrivialABI));
7151 Record->setTrivialForCallFlags(M);
7152 }
7153 }
7154
7155 // Set triviality for the purpose of calls if this is a user-provided
7156 // copy/move constructor or destructor.
7157 if ((CSM == CXXSpecialMemberKind::CopyConstructor ||
7158 CSM == CXXSpecialMemberKind::MoveConstructor ||
7159 CSM == CXXSpecialMemberKind::Destructor) &&
7160 M->isUserProvided()) {
7161 M->setTrivialForCall(HasTrivialABI);
7162 Record->setTrivialForCallFlags(M);
7163 }
7164
7165 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
7166 M->hasAttr<DLLExportAttr>()) {
7167 if (getLangOpts().isCompatibleWithMSVC(MajorVersion: LangOptions::MSVC2015) &&
7168 M->isTrivial() &&
7169 (CSM == CXXSpecialMemberKind::DefaultConstructor ||
7170 CSM == CXXSpecialMemberKind::CopyConstructor ||
7171 CSM == CXXSpecialMemberKind::Destructor))
7172 M->dropAttr<DLLExportAttr>();
7173
7174 if (M->hasAttr<DLLExportAttr>()) {
7175 // Define after any fields with in-class initializers have been parsed.
7176 DelayedDllExportMemberFunctions.push_back(Elt: M);
7177 }
7178 }
7179
7180 bool EffectivelyConstexprDestructor = true;
7181 // Avoid triggering vtable instantiation due to a dtor that is not
7182 // "effectively constexpr" for better compatibility.
7183 // See https://github.com/llvm/llvm-project/issues/102293 for more info.
7184 if (isa<CXXDestructorDecl>(Val: M)) {
7185 llvm::SmallDenseSet<QualType> Visited;
7186 auto Check = [&Visited](QualType T, auto &&Check) -> bool {
7187 if (!Visited.insert(V: T->getCanonicalTypeUnqualified()).second)
7188 return false;
7189 const CXXRecordDecl *RD =
7190 T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
7191 if (!RD || !RD->isCompleteDefinition())
7192 return true;
7193
7194 if (!RD->hasConstexprDestructor())
7195 return false;
7196
7197 for (const CXXBaseSpecifier &B : RD->bases())
7198 if (!Check(B.getType(), Check))
7199 return false;
7200 for (const FieldDecl *FD : RD->fields())
7201 if (!Check(FD->getType(), Check))
7202 return false;
7203 return true;
7204 };
7205 EffectivelyConstexprDestructor =
7206 Check(Context.getCanonicalTagType(TD: Record), Check);
7207 }
7208
7209 // Define defaulted constexpr virtual functions that override a base class
7210 // function right away.
7211 // FIXME: We can defer doing this until the vtable is marked as used.
7212 if (CSM != CXXSpecialMemberKind::Invalid && !M->isDeleted() &&
7213 M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods() &&
7214 EffectivelyConstexprDestructor)
7215 DefineDefaultedFunction(S&: *this, FD: M, DefaultLoc: M->getLocation());
7216
7217 if (!Incomplete)
7218 CheckCompletedMemberFunction(M);
7219 };
7220
7221 // Check the destructor before any other member function. We need to
7222 // determine whether it's trivial in order to determine whether the claas
7223 // type is a literal type, which is a prerequisite for determining whether
7224 // other special member functions are valid and whether they're implicitly
7225 // 'constexpr'.
7226 if (CXXDestructorDecl *Dtor = Record->getDestructor())
7227 CompleteMemberFunction(Dtor);
7228
7229 bool HasMethodWithOverrideControl = false,
7230 HasOverridingMethodWithoutOverrideControl = false;
7231 for (auto *D : Record->decls()) {
7232 if (auto *M = dyn_cast<CXXMethodDecl>(Val: D)) {
7233 // FIXME: We could do this check for dependent types with non-dependent
7234 // bases.
7235 if (!Record->isDependentType()) {
7236 // See if a method overloads virtual methods in a base
7237 // class without overriding any.
7238 if (!M->isStatic())
7239 DiagnoseHiddenVirtualMethods(MD: M);
7240
7241 if (M->hasAttr<OverrideAttr>()) {
7242 HasMethodWithOverrideControl = true;
7243 } else if (M->size_overridden_methods() > 0) {
7244 HasOverridingMethodWithoutOverrideControl = true;
7245 } else {
7246 // Warn on newly-declared virtual methods in `final` classes
7247 if (M->isVirtualAsWritten() && Record->isEffectivelyFinal()) {
7248 Diag(Loc: M->getLocation(), DiagID: diag::warn_unnecessary_virtual_specifier)
7249 << M;
7250 }
7251 }
7252 }
7253
7254 if (!isa<CXXDestructorDecl>(Val: M))
7255 CompleteMemberFunction(M);
7256 } else if (auto *F = dyn_cast<FriendDecl>(Val: D)) {
7257 CheckForDefaultedFunction(
7258 dyn_cast_or_null<FunctionDecl>(Val: F->getFriendDecl()));
7259 }
7260 }
7261
7262 if (HasOverridingMethodWithoutOverrideControl) {
7263 bool HasInconsistentOverrideControl = HasMethodWithOverrideControl;
7264 for (auto *M : Record->methods())
7265 DiagnoseAbsenceOfOverrideControl(D: M, Inconsistent: HasInconsistentOverrideControl);
7266 }
7267
7268 // Check the defaulted secondary comparisons after any other member functions.
7269 for (FunctionDecl *FD : DefaultedSecondaryComparisons) {
7270 CheckExplicitlyDefaultedFunction(S, MD: FD);
7271
7272 // If this is a member function, we deferred checking it until now.
7273 if (auto *MD = dyn_cast<CXXMethodDecl>(Val: FD))
7274 CheckCompletedMemberFunction(MD);
7275 }
7276
7277 // {ms,gcc}_struct is a request to change ABI rules to either follow
7278 // Microsoft or Itanium C++ ABI. However, even if these attributes are
7279 // present, we do not layout classes following foreign ABI rules, but
7280 // instead enter a special "compatibility mode", which only changes
7281 // alignments of fundamental types and layout of bit fields.
7282 // Check whether this class uses any C++ features that are implemented
7283 // completely differently in the requested ABI, and if so, emit a
7284 // diagnostic. That diagnostic defaults to an error, but we allow
7285 // projects to map it down to a warning (or ignore it). It's a fairly
7286 // common practice among users of the ms_struct pragma to
7287 // mass-annotate headers, sweeping up a bunch of types that the
7288 // project doesn't really rely on MSVC-compatible layout for. We must
7289 // therefore support "ms_struct except for C++ stuff" as a secondary
7290 // ABI.
7291 // Don't emit this diagnostic if the feature was enabled as a
7292 // language option (as opposed to via a pragma or attribute), as
7293 // the option -mms-bitfields otherwise essentially makes it impossible
7294 // to build C++ code, unless this diagnostic is turned off.
7295 if (Context.getLangOpts().getLayoutCompatibility() ==
7296 LangOptions::LayoutCompatibilityKind::Default &&
7297 Record->isMsStruct(C: Context) != Context.defaultsToMsStruct() &&
7298 (Record->isPolymorphic() || Record->getNumBases())) {
7299 Diag(Loc: Record->getLocation(), DiagID: diag::warn_cxx_ms_struct);
7300 }
7301
7302 checkClassLevelDLLAttribute(Class: Record);
7303 checkClassLevelCodeSegAttribute(Class: Record);
7304
7305 bool ClangABICompat4 =
7306 Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver4;
7307 TargetInfo::CallingConvKind CCK =
7308 Context.getTargetInfo().getCallingConvKind(ClangABICompat4);
7309 bool CanPass = canPassInRegisters(S&: *this, D: Record, CCK);
7310
7311 // Do not change ArgPassingRestrictions if it has already been set to
7312 // RecordArgPassingKind::CanNeverPassInRegs.
7313 if (Record->getArgPassingRestrictions() !=
7314 RecordArgPassingKind::CanNeverPassInRegs)
7315 Record->setArgPassingRestrictions(
7316 CanPass ? RecordArgPassingKind::CanPassInRegs
7317 : RecordArgPassingKind::CannotPassInRegs);
7318
7319 // If canPassInRegisters returns true despite the record having a non-trivial
7320 // destructor, the record is destructed in the callee. This happens only when
7321 // the record or one of its subobjects has a field annotated with trivial_abi
7322 // or a field qualified with ObjC __strong/__weak.
7323 if (Context.getTargetInfo().getCXXABI().areArgsDestroyedLeftToRightInCallee())
7324 Record->setParamDestroyedInCallee(true);
7325 else if (Record->hasNonTrivialDestructor())
7326 Record->setParamDestroyedInCallee(CanPass);
7327
7328 if (getLangOpts().ForceEmitVTables) {
7329 // If we want to emit all the vtables, we need to mark it as used. This
7330 // is especially required for cases like vtable assumption loads.
7331 MarkVTableUsed(Loc: Record->getInnerLocStart(), Class: Record);
7332 }
7333
7334 if (getLangOpts().CUDA) {
7335 if (Record->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())
7336 checkCUDADeviceBuiltinSurfaceClassTemplate(S&: *this, Class: Record);
7337 else if (Record->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())
7338 checkCUDADeviceBuiltinTextureClassTemplate(S&: *this, Class: Record);
7339 }
7340
7341 llvm::SmallDenseMap<OverloadedOperatorKind,
7342 llvm::SmallVector<const FunctionDecl *, 2>, 4>
7343 TypeAwareDecls{{OO_New, {}},
7344 {OO_Array_New, {}},
7345 {OO_Delete, {}},
7346 {OO_Array_New, {}}};
7347 for (auto *D : Record->decls()) {
7348 const FunctionDecl *FnDecl = D->getAsFunction();
7349 if (!FnDecl || !FnDecl->isTypeAwareOperatorNewOrDelete())
7350 continue;
7351 assert(FnDecl->getDeclName().isAnyOperatorNewOrDelete());
7352 TypeAwareDecls[FnDecl->getOverloadedOperator()].push_back(Elt: FnDecl);
7353 }
7354 auto CheckMismatchedTypeAwareAllocators =
7355 [this, &TypeAwareDecls, Record](OverloadedOperatorKind NewKind,
7356 OverloadedOperatorKind DeleteKind) {
7357 auto &NewDecls = TypeAwareDecls[NewKind];
7358 auto &DeleteDecls = TypeAwareDecls[DeleteKind];
7359 if (NewDecls.empty() == DeleteDecls.empty())
7360 return;
7361 DeclarationName FoundOperator =
7362 Context.DeclarationNames.getCXXOperatorName(
7363 Op: NewDecls.empty() ? DeleteKind : NewKind);
7364 DeclarationName MissingOperator =
7365 Context.DeclarationNames.getCXXOperatorName(
7366 Op: NewDecls.empty() ? NewKind : DeleteKind);
7367 Diag(Loc: Record->getLocation(),
7368 DiagID: diag::err_type_aware_allocator_missing_matching_operator)
7369 << FoundOperator << Context.getCanonicalTagType(TD: Record)
7370 << MissingOperator;
7371 for (auto MD : NewDecls)
7372 Diag(Loc: MD->getLocation(),
7373 DiagID: diag::note_unmatched_type_aware_allocator_declared)
7374 << MD;
7375 for (auto MD : DeleteDecls)
7376 Diag(Loc: MD->getLocation(),
7377 DiagID: diag::note_unmatched_type_aware_allocator_declared)
7378 << MD;
7379 };
7380 CheckMismatchedTypeAwareAllocators(OO_New, OO_Delete);
7381 CheckMismatchedTypeAwareAllocators(OO_Array_New, OO_Array_Delete);
7382}
7383
7384/// Look up the special member function that would be called by a special
7385/// member function for a subobject of class type.
7386///
7387/// \param Class The class type of the subobject.
7388/// \param CSM The kind of special member function.
7389/// \param FieldQuals If the subobject is a field, its cv-qualifiers.
7390/// \param ConstRHS True if this is a copy operation with a const object
7391/// on its RHS, that is, if the argument to the outer special member
7392/// function is 'const' and this is not a field marked 'mutable'.
7393static Sema::SpecialMemberOverloadResult
7394lookupCallFromSpecialMember(Sema &S, CXXRecordDecl *Class,
7395 CXXSpecialMemberKind CSM, unsigned FieldQuals,
7396 bool ConstRHS) {
7397 unsigned LHSQuals = 0;
7398 if (CSM == CXXSpecialMemberKind::CopyAssignment ||
7399 CSM == CXXSpecialMemberKind::MoveAssignment)
7400 LHSQuals = FieldQuals;
7401
7402 unsigned RHSQuals = FieldQuals;
7403 if (CSM == CXXSpecialMemberKind::DefaultConstructor ||
7404 CSM == CXXSpecialMemberKind::Destructor)
7405 RHSQuals = 0;
7406 else if (ConstRHS)
7407 RHSQuals |= Qualifiers::Const;
7408
7409 return S.LookupSpecialMember(D: Class, SM: CSM,
7410 ConstArg: RHSQuals & Qualifiers::Const,
7411 VolatileArg: RHSQuals & Qualifiers::Volatile,
7412 RValueThis: false,
7413 ConstThis: LHSQuals & Qualifiers::Const,
7414 VolatileThis: LHSQuals & Qualifiers::Volatile);
7415}
7416
7417class Sema::InheritedConstructorInfo {
7418 Sema &S;
7419 SourceLocation UseLoc;
7420
7421 /// A mapping from the base classes through which the constructor was
7422 /// inherited to the using shadow declaration in that base class (or a null
7423 /// pointer if the constructor was declared in that base class).
7424 llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
7425 InheritedFromBases;
7426
7427public:
7428 InheritedConstructorInfo(Sema &S, SourceLocation UseLoc,
7429 ConstructorUsingShadowDecl *Shadow)
7430 : S(S), UseLoc(UseLoc) {
7431 bool DiagnosedMultipleConstructedBases = false;
7432 CXXRecordDecl *ConstructedBase = nullptr;
7433 BaseUsingDecl *ConstructedBaseIntroducer = nullptr;
7434
7435 // Find the set of such base class subobjects and check that there's a
7436 // unique constructed subobject.
7437 for (auto *D : Shadow->redecls()) {
7438 auto *DShadow = cast<ConstructorUsingShadowDecl>(Val: D);
7439 auto *DNominatedBase = DShadow->getNominatedBaseClass();
7440 auto *DConstructedBase = DShadow->getConstructedBaseClass();
7441
7442 InheritedFromBases.insert(
7443 KV: std::make_pair(x: DNominatedBase->getCanonicalDecl(),
7444 y: DShadow->getNominatedBaseClassShadowDecl()));
7445 if (DShadow->constructsVirtualBase())
7446 InheritedFromBases.insert(
7447 KV: std::make_pair(x: DConstructedBase->getCanonicalDecl(),
7448 y: DShadow->getConstructedBaseClassShadowDecl()));
7449 else
7450 assert(DNominatedBase == DConstructedBase);
7451
7452 // [class.inhctor.init]p2:
7453 // If the constructor was inherited from multiple base class subobjects
7454 // of type B, the program is ill-formed.
7455 if (!ConstructedBase) {
7456 ConstructedBase = DConstructedBase;
7457 ConstructedBaseIntroducer = D->getIntroducer();
7458 } else if (ConstructedBase != DConstructedBase &&
7459 !Shadow->isInvalidDecl()) {
7460 if (!DiagnosedMultipleConstructedBases) {
7461 S.Diag(Loc: UseLoc, DiagID: diag::err_ambiguous_inherited_constructor)
7462 << Shadow->getTargetDecl();
7463 S.Diag(Loc: ConstructedBaseIntroducer->getLocation(),
7464 DiagID: diag::note_ambiguous_inherited_constructor_using)
7465 << ConstructedBase;
7466 DiagnosedMultipleConstructedBases = true;
7467 }
7468 S.Diag(Loc: D->getIntroducer()->getLocation(),
7469 DiagID: diag::note_ambiguous_inherited_constructor_using)
7470 << DConstructedBase;
7471 }
7472 }
7473
7474 if (DiagnosedMultipleConstructedBases)
7475 Shadow->setInvalidDecl();
7476 }
7477
7478 /// Find the constructor to use for inherited construction of a base class,
7479 /// and whether that base class constructor inherits the constructor from a
7480 /// virtual base class (in which case it won't actually invoke it).
7481 std::pair<CXXConstructorDecl *, bool>
7482 findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const {
7483 auto It = InheritedFromBases.find(Val: Base->getCanonicalDecl());
7484 if (It == InheritedFromBases.end())
7485 return std::make_pair(x: nullptr, y: false);
7486
7487 // This is an intermediary class.
7488 if (It->second)
7489 return std::make_pair(
7490 x: S.findInheritingConstructor(Loc: UseLoc, BaseCtor: Ctor, DerivedShadow: It->second),
7491 y: It->second->constructsVirtualBase());
7492
7493 // This is the base class from which the constructor was inherited.
7494 return std::make_pair(x&: Ctor, y: false);
7495 }
7496};
7497
7498/// Is the special member function which would be selected to perform the
7499/// specified operation on the specified class type a constexpr constructor?
7500static bool specialMemberIsConstexpr(
7501 Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, unsigned Quals,
7502 bool ConstRHS, CXXConstructorDecl *InheritedCtor = nullptr,
7503 Sema::InheritedConstructorInfo *Inherited = nullptr) {
7504 // Suppress duplicate constraint checking here, in case a constraint check
7505 // caused us to decide to do this. Any truely recursive checks will get
7506 // caught during these checks anyway.
7507 Sema::SatisfactionStackResetRAII SSRAII{S};
7508
7509 // If we're inheriting a constructor, see if we need to call it for this base
7510 // class.
7511 if (InheritedCtor) {
7512 assert(CSM == CXXSpecialMemberKind::DefaultConstructor);
7513 auto BaseCtor =
7514 Inherited->findConstructorForBase(Base: ClassDecl, Ctor: InheritedCtor).first;
7515 if (BaseCtor)
7516 return BaseCtor->isConstexpr();
7517 }
7518
7519 if (CSM == CXXSpecialMemberKind::DefaultConstructor)
7520 return ClassDecl->hasConstexprDefaultConstructor();
7521 if (CSM == CXXSpecialMemberKind::Destructor)
7522 return ClassDecl->hasConstexprDestructor();
7523
7524 Sema::SpecialMemberOverloadResult SMOR =
7525 lookupCallFromSpecialMember(S, Class: ClassDecl, CSM, FieldQuals: Quals, ConstRHS);
7526 if (!SMOR.getMethod())
7527 // A constructor we wouldn't select can't be "involved in initializing"
7528 // anything.
7529 return true;
7530 return SMOR.getMethod()->isConstexpr();
7531}
7532
7533/// Determine whether the specified special member function would be constexpr
7534/// if it were implicitly defined.
7535static bool defaultedSpecialMemberIsConstexpr(
7536 Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, bool ConstArg,
7537 CXXConstructorDecl *InheritedCtor = nullptr,
7538 Sema::InheritedConstructorInfo *Inherited = nullptr) {
7539 if (!S.getLangOpts().CPlusPlus11)
7540 return false;
7541
7542 // C++11 [dcl.constexpr]p4:
7543 // In the definition of a constexpr constructor [...]
7544 bool Ctor = true;
7545 switch (CSM) {
7546 case CXXSpecialMemberKind::DefaultConstructor:
7547 if (Inherited)
7548 break;
7549 // Since default constructor lookup is essentially trivial (and cannot
7550 // involve, for instance, template instantiation), we compute whether a
7551 // defaulted default constructor is constexpr directly within CXXRecordDecl.
7552 //
7553 // This is important for performance; we need to know whether the default
7554 // constructor is constexpr to determine whether the type is a literal type.
7555 return ClassDecl->defaultedDefaultConstructorIsConstexpr();
7556
7557 case CXXSpecialMemberKind::CopyConstructor:
7558 case CXXSpecialMemberKind::MoveConstructor:
7559 // For copy or move constructors, we need to perform overload resolution.
7560 break;
7561
7562 case CXXSpecialMemberKind::CopyAssignment:
7563 case CXXSpecialMemberKind::MoveAssignment:
7564 if (!S.getLangOpts().CPlusPlus14)
7565 return false;
7566 // In C++1y, we need to perform overload resolution.
7567 Ctor = false;
7568 break;
7569
7570 case CXXSpecialMemberKind::Destructor:
7571 return ClassDecl->defaultedDestructorIsConstexpr();
7572
7573 case CXXSpecialMemberKind::Invalid:
7574 return false;
7575 }
7576
7577 // -- if the class is a non-empty union, or for each non-empty anonymous
7578 // union member of a non-union class, exactly one non-static data member
7579 // shall be initialized; [DR1359]
7580 //
7581 // If we squint, this is guaranteed, since exactly one non-static data member
7582 // will be initialized (if the constructor isn't deleted), we just don't know
7583 // which one.
7584 if (Ctor && ClassDecl->isUnion())
7585 return CSM == CXXSpecialMemberKind::DefaultConstructor
7586 ? ClassDecl->hasInClassInitializer() ||
7587 !ClassDecl->hasVariantMembers()
7588 : true;
7589
7590 // -- the class shall not have any virtual base classes;
7591 if (Ctor && ClassDecl->getNumVBases())
7592 return false;
7593
7594 // C++1y [class.copy]p26:
7595 // -- [the class] is a literal type, and
7596 if (!Ctor && !ClassDecl->isLiteral() && !S.getLangOpts().CPlusPlus23)
7597 return false;
7598
7599 // -- every constructor involved in initializing [...] base class
7600 // sub-objects shall be a constexpr constructor;
7601 // -- the assignment operator selected to copy/move each direct base
7602 // class is a constexpr function, and
7603 if (!S.getLangOpts().CPlusPlus23) {
7604 for (const auto &B : ClassDecl->bases()) {
7605 auto *BaseClassDecl = B.getType()->getAsCXXRecordDecl();
7606 if (!BaseClassDecl)
7607 continue;
7608 if (!specialMemberIsConstexpr(S, ClassDecl: BaseClassDecl, CSM, Quals: 0, ConstRHS: ConstArg,
7609 InheritedCtor, Inherited))
7610 return false;
7611 }
7612 }
7613
7614 // -- every constructor involved in initializing non-static data members
7615 // [...] shall be a constexpr constructor;
7616 // -- every non-static data member and base class sub-object shall be
7617 // initialized
7618 // -- for each non-static data member of X that is of class type (or array
7619 // thereof), the assignment operator selected to copy/move that member is
7620 // a constexpr function
7621 if (!S.getLangOpts().CPlusPlus23) {
7622 for (const auto *F : ClassDecl->fields()) {
7623 if (F->isInvalidDecl())
7624 continue;
7625 if (CSM == CXXSpecialMemberKind::DefaultConstructor &&
7626 F->hasInClassInitializer())
7627 continue;
7628 QualType BaseType = S.Context.getBaseElementType(QT: F->getType());
7629 if (const RecordType *RecordTy = BaseType->getAsCanonical<RecordType>()) {
7630 auto *FieldRecDecl =
7631 cast<CXXRecordDecl>(Val: RecordTy->getDecl())->getDefinitionOrSelf();
7632 if (!specialMemberIsConstexpr(S, ClassDecl: FieldRecDecl, CSM,
7633 Quals: BaseType.getCVRQualifiers(),
7634 ConstRHS: ConstArg && !F->isMutable()))
7635 return false;
7636 } else if (CSM == CXXSpecialMemberKind::DefaultConstructor) {
7637 return false;
7638 }
7639 }
7640 }
7641
7642 // All OK, it's constexpr!
7643 return true;
7644}
7645
7646namespace {
7647/// RAII object to register a defaulted function as having its exception
7648/// specification computed.
7649struct ComputingExceptionSpec {
7650 Sema &S;
7651
7652 ComputingExceptionSpec(Sema &S, FunctionDecl *FD, SourceLocation Loc)
7653 : S(S) {
7654 Sema::CodeSynthesisContext Ctx;
7655 Ctx.Kind = Sema::CodeSynthesisContext::ExceptionSpecEvaluation;
7656 Ctx.PointOfInstantiation = Loc;
7657 Ctx.Entity = FD;
7658 S.pushCodeSynthesisContext(Ctx);
7659 }
7660 ~ComputingExceptionSpec() {
7661 S.popCodeSynthesisContext();
7662 }
7663};
7664}
7665
7666static Sema::ImplicitExceptionSpecification
7667ComputeDefaultedSpecialMemberExceptionSpec(Sema &S, SourceLocation Loc,
7668 CXXMethodDecl *MD,
7669 CXXSpecialMemberKind CSM,
7670 Sema::InheritedConstructorInfo *ICI);
7671
7672static Sema::ImplicitExceptionSpecification
7673ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc,
7674 FunctionDecl *FD,
7675 Sema::DefaultedComparisonKind DCK);
7676
7677static Sema::ImplicitExceptionSpecification
7678computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD) {
7679 auto DFK = S.getDefaultedFunctionKind(FD);
7680 if (DFK.isSpecialMember())
7681 return ComputeDefaultedSpecialMemberExceptionSpec(
7682 S, Loc, MD: cast<CXXMethodDecl>(Val: FD), CSM: DFK.asSpecialMember(), ICI: nullptr);
7683 if (DFK.isComparison())
7684 return ComputeDefaultedComparisonExceptionSpec(S, Loc, FD,
7685 DCK: DFK.asComparison());
7686
7687 auto *CD = cast<CXXConstructorDecl>(Val: FD);
7688 assert(CD->getInheritedConstructor() &&
7689 "only defaulted functions and inherited constructors have implicit "
7690 "exception specs");
7691 Sema::InheritedConstructorInfo ICI(
7692 S, Loc, CD->getInheritedConstructor().getShadowDecl());
7693 return ComputeDefaultedSpecialMemberExceptionSpec(
7694 S, Loc, MD: CD, CSM: CXXSpecialMemberKind::DefaultConstructor, ICI: &ICI);
7695}
7696
7697static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S,
7698 CXXMethodDecl *MD) {
7699 FunctionProtoType::ExtProtoInfo EPI;
7700
7701 // Build an exception specification pointing back at this member.
7702 EPI.ExceptionSpec.Type = EST_Unevaluated;
7703 EPI.ExceptionSpec.SourceDecl = MD;
7704
7705 // Set the calling convention to the default for C++ instance methods.
7706 EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
7707 cc: S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
7708 /*IsCXXMethod=*/true));
7709 return EPI;
7710}
7711
7712void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD) {
7713 const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
7714 if (FPT->getExceptionSpecType() != EST_Unevaluated)
7715 return;
7716
7717 // Evaluate the exception specification.
7718 auto IES = computeImplicitExceptionSpec(S&: *this, Loc, FD);
7719 auto ESI = IES.getExceptionSpec();
7720
7721 // Update the type of the special member to use it.
7722 UpdateExceptionSpec(FD, ESI);
7723}
7724
7725void Sema::CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *FD) {
7726 assert(FD->isExplicitlyDefaulted() && "not explicitly-defaulted");
7727
7728 DefaultedFunctionKind DefKind = getDefaultedFunctionKind(FD);
7729 if (!DefKind) {
7730 assert(FD->getDeclContext()->isDependentContext());
7731 return;
7732 }
7733
7734 if (DefKind.isComparison()) {
7735 auto PT = FD->getParamDecl(i: 0)->getType();
7736 if (const CXXRecordDecl *RD =
7737 PT.getNonReferenceType()->getAsCXXRecordDecl()) {
7738 for (FieldDecl *Field : RD->fields()) {
7739 UnusedPrivateFields.remove(X: Field);
7740 }
7741 }
7742 }
7743
7744 if (DefKind.isSpecialMember()
7745 ? CheckExplicitlyDefaultedSpecialMember(MD: cast<CXXMethodDecl>(Val: FD),
7746 CSM: DefKind.asSpecialMember(),
7747 DefaultLoc: FD->getDefaultLoc())
7748 : CheckExplicitlyDefaultedComparison(S, MD: FD, DCK: DefKind.asComparison()))
7749 FD->setInvalidDecl();
7750}
7751
7752bool Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
7753 CXXSpecialMemberKind CSM,
7754 SourceLocation DefaultLoc) {
7755 CXXRecordDecl *RD = MD->getParent();
7756
7757 assert(MD->isExplicitlyDefaulted() && CSM != CXXSpecialMemberKind::Invalid &&
7758 "not an explicitly-defaulted special member");
7759
7760 // Defer all checking for special members of a dependent type.
7761 if (RD->isDependentType())
7762 return false;
7763
7764 // Whether this was the first-declared instance of the constructor.
7765 // This affects whether we implicitly add an exception spec and constexpr.
7766 bool First = MD == MD->getCanonicalDecl();
7767
7768 bool HadError = false;
7769
7770 // C++11 [dcl.fct.def.default]p1:
7771 // A function that is explicitly defaulted shall
7772 // -- be a special member function [...] (checked elsewhere),
7773 // -- have the same type (except for ref-qualifiers, and except that a
7774 // copy operation can take a non-const reference) as an implicit
7775 // declaration, and
7776 // -- not have default arguments.
7777 // C++2a changes the second bullet to instead delete the function if it's
7778 // defaulted on its first declaration, unless it's "an assignment operator,
7779 // and its return type differs or its parameter type is not a reference".
7780 bool DeleteOnTypeMismatch = getLangOpts().CPlusPlus20 && First;
7781 bool ShouldDeleteForTypeMismatch = false;
7782 unsigned ExpectedParams = 1;
7783 if (CSM == CXXSpecialMemberKind::DefaultConstructor ||
7784 CSM == CXXSpecialMemberKind::Destructor)
7785 ExpectedParams = 0;
7786 if (MD->getNumExplicitParams() != ExpectedParams) {
7787 // This checks for default arguments: a copy or move constructor with a
7788 // default argument is classified as a default constructor, and assignment
7789 // operations and destructors can't have default arguments.
7790 Diag(Loc: MD->getLocation(), DiagID: diag::err_defaulted_special_member_params)
7791 << CSM << MD->getSourceRange();
7792 HadError = true;
7793 } else if (MD->isVariadic()) {
7794 if (DeleteOnTypeMismatch)
7795 ShouldDeleteForTypeMismatch = true;
7796 else {
7797 Diag(Loc: MD->getLocation(), DiagID: diag::err_defaulted_special_member_variadic)
7798 << CSM << MD->getSourceRange();
7799 HadError = true;
7800 }
7801 }
7802
7803 const FunctionProtoType *Type = MD->getType()->castAs<FunctionProtoType>();
7804
7805 bool CanHaveConstParam = false;
7806 if (CSM == CXXSpecialMemberKind::CopyConstructor)
7807 CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
7808 else if (CSM == CXXSpecialMemberKind::CopyAssignment)
7809 CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
7810
7811 QualType ReturnType = Context.VoidTy;
7812 if (CSM == CXXSpecialMemberKind::CopyAssignment ||
7813 CSM == CXXSpecialMemberKind::MoveAssignment) {
7814 // Check for return type matching.
7815 ReturnType = Type->getReturnType();
7816 QualType ThisType = MD->getFunctionObjectParameterType();
7817
7818 QualType DeclType =
7819 Context.getTagType(Keyword: ElaboratedTypeKeyword::None,
7820 /*Qualifier=*/std::nullopt, TD: RD, /*OwnsTag=*/false);
7821 DeclType = Context.getAddrSpaceQualType(
7822 T: DeclType, AddressSpace: ThisType.getQualifiers().getAddressSpace());
7823 QualType ExpectedReturnType = Context.getLValueReferenceType(T: DeclType);
7824
7825 if (!Context.hasSameType(T1: ReturnType, T2: ExpectedReturnType)) {
7826 Diag(Loc: MD->getLocation(), DiagID: diag::err_defaulted_special_member_return_type)
7827 << (CSM == CXXSpecialMemberKind::MoveAssignment)
7828 << ExpectedReturnType;
7829 HadError = true;
7830 }
7831
7832 // A defaulted special member cannot have cv-qualifiers.
7833 if (ThisType.isConstQualified() || ThisType.isVolatileQualified()) {
7834 if (DeleteOnTypeMismatch)
7835 ShouldDeleteForTypeMismatch = true;
7836 else {
7837 Diag(Loc: MD->getLocation(), DiagID: diag::err_defaulted_special_member_quals)
7838 << (CSM == CXXSpecialMemberKind::MoveAssignment)
7839 << getLangOpts().CPlusPlus14;
7840 HadError = true;
7841 }
7842 }
7843 // [C++23][dcl.fct.def.default]/p2.2
7844 // if F2 has an implicit object parameter of type “reference to C”,
7845 // F1 may be an explicit object member function whose explicit object
7846 // parameter is of (possibly different) type “reference to C”,
7847 // in which case the type of F1 would differ from the type of F2
7848 // in that the type of F1 has an additional parameter;
7849 QualType ExplicitObjectParameter = MD->isExplicitObjectMemberFunction()
7850 ? MD->getParamDecl(i: 0)->getType()
7851 : QualType();
7852 if (!ExplicitObjectParameter.isNull() &&
7853 (!ExplicitObjectParameter->isReferenceType() ||
7854 !Context.hasSameType(T1: ExplicitObjectParameter.getNonReferenceType(),
7855 T2: Context.getCanonicalTagType(TD: RD)))) {
7856 if (DeleteOnTypeMismatch)
7857 ShouldDeleteForTypeMismatch = true;
7858 else {
7859 Diag(Loc: MD->getLocation(),
7860 DiagID: diag::err_defaulted_special_member_explicit_object_mismatch)
7861 << (CSM == CXXSpecialMemberKind::MoveAssignment) << RD
7862 << MD->getSourceRange();
7863 HadError = true;
7864 }
7865 }
7866 }
7867
7868 // Check for parameter type matching.
7869 QualType ArgType =
7870 ExpectedParams
7871 ? Type->getParamType(i: MD->isExplicitObjectMemberFunction() ? 1 : 0)
7872 : QualType();
7873 bool HasConstParam = false;
7874 if (ExpectedParams && ArgType->isReferenceType()) {
7875 // Argument must be reference to possibly-const T.
7876 QualType ReferentType = ArgType->getPointeeType();
7877 HasConstParam = ReferentType.isConstQualified();
7878
7879 if (ReferentType.isVolatileQualified()) {
7880 if (DeleteOnTypeMismatch)
7881 ShouldDeleteForTypeMismatch = true;
7882 else {
7883 Diag(Loc: MD->getLocation(),
7884 DiagID: diag::err_defaulted_special_member_volatile_param)
7885 << CSM;
7886 HadError = true;
7887 }
7888 }
7889
7890 if (HasConstParam && !CanHaveConstParam) {
7891 if (DeleteOnTypeMismatch)
7892 ShouldDeleteForTypeMismatch = true;
7893 else if (CSM == CXXSpecialMemberKind::CopyConstructor ||
7894 CSM == CXXSpecialMemberKind::CopyAssignment) {
7895 Diag(Loc: MD->getLocation(),
7896 DiagID: diag::err_defaulted_special_member_copy_const_param)
7897 << (CSM == CXXSpecialMemberKind::CopyAssignment);
7898 // FIXME: Explain why this special member can't be const.
7899 HadError = true;
7900 } else {
7901 Diag(Loc: MD->getLocation(),
7902 DiagID: diag::err_defaulted_special_member_move_const_param)
7903 << (CSM == CXXSpecialMemberKind::MoveAssignment);
7904 HadError = true;
7905 }
7906 }
7907 } else if (ExpectedParams) {
7908 // A copy assignment operator can take its argument by value, but a
7909 // defaulted one cannot.
7910 assert(CSM == CXXSpecialMemberKind::CopyAssignment &&
7911 "unexpected non-ref argument");
7912 Diag(Loc: MD->getLocation(), DiagID: diag::err_defaulted_copy_assign_not_ref);
7913 HadError = true;
7914 }
7915
7916 // C++11 [dcl.fct.def.default]p2:
7917 // An explicitly-defaulted function may be declared constexpr only if it
7918 // would have been implicitly declared as constexpr,
7919 // Do not apply this rule to members of class templates, since core issue 1358
7920 // makes such functions always instantiate to constexpr functions. For
7921 // functions which cannot be constexpr (for non-constructors in C++11 and for
7922 // destructors in C++14 and C++17), this is checked elsewhere.
7923 //
7924 // FIXME: This should not apply if the member is deleted.
7925 bool Constexpr = defaultedSpecialMemberIsConstexpr(S&: *this, ClassDecl: RD, CSM,
7926 ConstArg: HasConstParam);
7927
7928 // C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358):
7929 // If the instantiated template specialization of a constexpr function
7930 // template or member function of a class template would fail to satisfy
7931 // the requirements for a constexpr function or constexpr constructor, that
7932 // specialization is still a constexpr function or constexpr constructor,
7933 // even though a call to such a function cannot appear in a constant
7934 // expression.
7935 if (MD->isTemplateInstantiation() && MD->isConstexpr())
7936 Constexpr = true;
7937
7938 if ((getLangOpts().CPlusPlus20 ||
7939 (getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(Val: MD)
7940 : isa<CXXConstructorDecl>(Val: MD))) &&
7941 MD->isConstexpr() && !Constexpr &&
7942 MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
7943 if (!MD->isConsteval() && RD->getNumVBases()) {
7944 Diag(Loc: MD->getBeginLoc(),
7945 DiagID: diag::err_incorrect_defaulted_constexpr_with_vb)
7946 << CSM;
7947 for (const auto &I : RD->vbases())
7948 Diag(Loc: I.getBeginLoc(), DiagID: diag::note_constexpr_virtual_base_here);
7949 } else {
7950 Diag(Loc: MD->getBeginLoc(), DiagID: diag::err_incorrect_defaulted_constexpr)
7951 << CSM << MD->isConsteval();
7952 }
7953 HadError = true;
7954 // FIXME: Explain why the special member can't be constexpr.
7955 }
7956
7957 if (First) {
7958 // C++2a [dcl.fct.def.default]p3:
7959 // If a function is explicitly defaulted on its first declaration, it is
7960 // implicitly considered to be constexpr if the implicit declaration
7961 // would be.
7962 MD->setConstexprKind(Constexpr ? (MD->isConsteval()
7963 ? ConstexprSpecKind::Consteval
7964 : ConstexprSpecKind::Constexpr)
7965 : ConstexprSpecKind::Unspecified);
7966
7967 if (!Type->hasExceptionSpec()) {
7968 // C++2a [except.spec]p3:
7969 // If a declaration of a function does not have a noexcept-specifier
7970 // [and] is defaulted on its first declaration, [...] the exception
7971 // specification is as specified below
7972 FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
7973 EPI.ExceptionSpec.Type = EST_Unevaluated;
7974 EPI.ExceptionSpec.SourceDecl = MD;
7975 MD->setType(
7976 Context.getFunctionType(ResultTy: ReturnType, Args: Type->getParamTypes(), EPI));
7977 }
7978 }
7979
7980 if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {
7981 if (First) {
7982 SetDeclDeleted(dcl: MD, DelLoc: MD->getLocation());
7983 if (!inTemplateInstantiation() && !HadError) {
7984 Diag(Loc: MD->getLocation(), DiagID: diag::warn_defaulted_method_deleted) << CSM;
7985 if (ShouldDeleteForTypeMismatch) {
7986 Diag(Loc: MD->getLocation(), DiagID: diag::note_deleted_type_mismatch) << CSM;
7987 } else if (ShouldDeleteSpecialMember(MD, CSM, ICI: nullptr,
7988 /*Diagnose*/ true) &&
7989 DefaultLoc.isValid()) {
7990 Diag(Loc: DefaultLoc, DiagID: diag::note_replace_equals_default_to_delete)
7991 << FixItHint::CreateReplacement(RemoveRange: DefaultLoc, Code: "delete");
7992 }
7993 }
7994 if (ShouldDeleteForTypeMismatch && !HadError) {
7995 Diag(Loc: MD->getLocation(),
7996 DiagID: diag::warn_cxx17_compat_defaulted_method_type_mismatch)
7997 << CSM;
7998 }
7999 } else {
8000 // C++11 [dcl.fct.def.default]p4:
8001 // [For a] user-provided explicitly-defaulted function [...] if such a
8002 // function is implicitly defined as deleted, the program is ill-formed.
8003 Diag(Loc: MD->getLocation(), DiagID: diag::err_out_of_line_default_deletes) << CSM;
8004 assert(!ShouldDeleteForTypeMismatch && "deleted non-first decl");
8005 ShouldDeleteSpecialMember(MD, CSM, ICI: nullptr, /*Diagnose*/true);
8006 HadError = true;
8007 }
8008 }
8009
8010 return HadError;
8011}
8012
8013namespace {
8014/// Helper class for building and checking a defaulted comparison.
8015///
8016/// Defaulted functions are built in two phases:
8017///
8018/// * First, the set of operations that the function will perform are
8019/// identified, and some of them are checked. If any of the checked
8020/// operations is invalid in certain ways, the comparison function is
8021/// defined as deleted and no body is built.
8022/// * Then, if the function is not defined as deleted, the body is built.
8023///
8024/// This is accomplished by performing two visitation steps over the eventual
8025/// body of the function.
8026template<typename Derived, typename ResultList, typename Result,
8027 typename Subobject>
8028class DefaultedComparisonVisitor {
8029public:
8030 using DefaultedComparisonKind = Sema::DefaultedComparisonKind;
8031
8032 DefaultedComparisonVisitor(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
8033 DefaultedComparisonKind DCK)
8034 : S(S), RD(RD), FD(FD), DCK(DCK) {
8035 if (auto *Info = FD->getDefaultedOrDeletedInfo()) {
8036 // FIXME: Change CreateOverloadedBinOp to take an ArrayRef instead of an
8037 // UnresolvedSet to avoid this copy.
8038 Fns.assign(I: Info->getUnqualifiedLookups().begin(),
8039 E: Info->getUnqualifiedLookups().end());
8040 }
8041 }
8042
8043 ResultList visit() {
8044 // The type of an lvalue naming a parameter of this function.
8045 QualType ParamLvalType =
8046 FD->getParamDecl(i: 0)->getType().getNonReferenceType();
8047
8048 ResultList Results;
8049
8050 switch (DCK) {
8051 case DefaultedComparisonKind::None:
8052 llvm_unreachable("not a defaulted comparison");
8053
8054 case DefaultedComparisonKind::Equal:
8055 case DefaultedComparisonKind::ThreeWay:
8056 getDerived().visitSubobjects(Results, RD, ParamLvalType.getQualifiers());
8057 return Results;
8058
8059 case DefaultedComparisonKind::NotEqual:
8060 case DefaultedComparisonKind::Relational:
8061 Results.add(getDerived().visitExpandedSubobject(
8062 ParamLvalType, getDerived().getCompleteObject()));
8063 return Results;
8064 }
8065 llvm_unreachable("");
8066 }
8067
8068protected:
8069 Derived &getDerived() { return static_cast<Derived&>(*this); }
8070
8071 /// Visit the expanded list of subobjects of the given type, as specified in
8072 /// C++2a [class.compare.default].
8073 ///
8074 /// \return \c true if the ResultList object said we're done, \c false if not.
8075 bool visitSubobjects(ResultList &Results, CXXRecordDecl *Record,
8076 Qualifiers Quals) {
8077 // C++2a [class.compare.default]p4:
8078 // The direct base class subobjects of C
8079 for (CXXBaseSpecifier &Base : Record->bases())
8080 if (Results.add(getDerived().visitSubobject(
8081 S.Context.getQualifiedType(T: Base.getType(), Qs: Quals),
8082 getDerived().getBase(&Base))))
8083 return true;
8084
8085 // followed by the non-static data members of C
8086 for (FieldDecl *Field : Record->fields()) {
8087 // C++23 [class.bit]p2:
8088 // Unnamed bit-fields are not members ...
8089 if (Field->isUnnamedBitField())
8090 continue;
8091 // Recursively expand anonymous structs.
8092 if (Field->isAnonymousStructOrUnion()) {
8093 if (visitSubobjects(Results, Record: Field->getType()->getAsCXXRecordDecl(),
8094 Quals))
8095 return true;
8096 continue;
8097 }
8098
8099 // Figure out the type of an lvalue denoting this field.
8100 Qualifiers FieldQuals = Quals;
8101 if (Field->isMutable())
8102 FieldQuals.removeConst();
8103 QualType FieldType =
8104 S.Context.getQualifiedType(T: Field->getType(), Qs: FieldQuals);
8105
8106 if (Results.add(getDerived().visitSubobject(
8107 FieldType, getDerived().getField(Field))))
8108 return true;
8109 }
8110
8111 // form a list of subobjects.
8112 return false;
8113 }
8114
8115 Result visitSubobject(QualType Type, Subobject Subobj) {
8116 // In that list, any subobject of array type is recursively expanded
8117 const ArrayType *AT = S.Context.getAsArrayType(T: Type);
8118 if (auto *CAT = dyn_cast_or_null<ConstantArrayType>(Val: AT))
8119 return getDerived().visitSubobjectArray(CAT->getElementType(),
8120 CAT->getSize(), Subobj);
8121 return getDerived().visitExpandedSubobject(Type, Subobj);
8122 }
8123
8124 Result visitSubobjectArray(QualType Type, const llvm::APInt &Size,
8125 Subobject Subobj) {
8126 return getDerived().visitSubobject(Type, Subobj);
8127 }
8128
8129protected:
8130 Sema &S;
8131 CXXRecordDecl *RD;
8132 FunctionDecl *FD;
8133 DefaultedComparisonKind DCK;
8134 UnresolvedSet<16> Fns;
8135};
8136
8137/// Information about a defaulted comparison, as determined by
8138/// DefaultedComparisonAnalyzer.
8139struct DefaultedComparisonInfo {
8140 bool Deleted = false;
8141 bool Constexpr = true;
8142 ComparisonCategoryType Category = ComparisonCategoryType::StrongOrdering;
8143
8144 static DefaultedComparisonInfo deleted() {
8145 DefaultedComparisonInfo Deleted;
8146 Deleted.Deleted = true;
8147 return Deleted;
8148 }
8149
8150 bool add(const DefaultedComparisonInfo &R) {
8151 Deleted |= R.Deleted;
8152 Constexpr &= R.Constexpr;
8153 Category = commonComparisonType(A: Category, B: R.Category);
8154 return Deleted;
8155 }
8156};
8157
8158/// An element in the expanded list of subobjects of a defaulted comparison, as
8159/// specified in C++2a [class.compare.default]p4.
8160struct DefaultedComparisonSubobject {
8161 enum { CompleteObject, Member, Base } Kind;
8162 NamedDecl *Decl;
8163 SourceLocation Loc;
8164};
8165
8166/// A visitor over the notional body of a defaulted comparison that determines
8167/// whether that body would be deleted or constexpr.
8168class DefaultedComparisonAnalyzer
8169 : public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
8170 DefaultedComparisonInfo,
8171 DefaultedComparisonInfo,
8172 DefaultedComparisonSubobject> {
8173public:
8174 enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
8175
8176private:
8177 DiagnosticKind Diagnose;
8178
8179public:
8180 using Base = DefaultedComparisonVisitor;
8181 using Result = DefaultedComparisonInfo;
8182 using Subobject = DefaultedComparisonSubobject;
8183
8184 friend Base;
8185
8186 DefaultedComparisonAnalyzer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
8187 DefaultedComparisonKind DCK,
8188 DiagnosticKind Diagnose = NoDiagnostics)
8189 : Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
8190
8191 Result visit() {
8192 if ((DCK == DefaultedComparisonKind::Equal ||
8193 DCK == DefaultedComparisonKind::ThreeWay) &&
8194 RD->hasVariantMembers()) {
8195 // C++2a [class.compare.default]p2 [P2002R0]:
8196 // A defaulted comparison operator function for class C is defined as
8197 // deleted if [...] C has variant members.
8198 if (Diagnose == ExplainDeleted) {
8199 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_defaulted_comparison_union)
8200 << FD << RD->isUnion() << RD;
8201 }
8202 return Result::deleted();
8203 }
8204
8205 return Base::visit();
8206 }
8207
8208private:
8209 Subobject getCompleteObject() {
8210 return Subobject{.Kind: Subobject::CompleteObject, .Decl: RD, .Loc: FD->getLocation()};
8211 }
8212
8213 Subobject getBase(CXXBaseSpecifier *Base) {
8214 return Subobject{.Kind: Subobject::Base, .Decl: Base->getType()->getAsCXXRecordDecl(),
8215 .Loc: Base->getBaseTypeLoc()};
8216 }
8217
8218 Subobject getField(FieldDecl *Field) {
8219 return Subobject{.Kind: Subobject::Member, .Decl: Field, .Loc: Field->getLocation()};
8220 }
8221
8222 Result visitExpandedSubobject(QualType Type, Subobject Subobj) {
8223 // C++2a [class.compare.default]p2 [P2002R0]:
8224 // A defaulted <=> or == operator function for class C is defined as
8225 // deleted if any non-static data member of C is of reference type
8226 if (Type->isReferenceType()) {
8227 if (Diagnose == ExplainDeleted) {
8228 S.Diag(Loc: Subobj.Loc, DiagID: diag::note_defaulted_comparison_reference_member)
8229 << FD << RD;
8230 }
8231 return Result::deleted();
8232 }
8233
8234 // [...] Let xi be an lvalue denoting the ith element [...]
8235 OpaqueValueExpr Xi(FD->getLocation(), Type, VK_LValue);
8236 Expr *Args[] = {&Xi, &Xi};
8237
8238 // All operators start by trying to apply that same operator recursively.
8239 OverloadedOperatorKind OO = FD->getOverloadedOperator();
8240 assert(OO != OO_None && "not an overloaded operator!");
8241 return visitBinaryOperator(OO, Args, Subobj);
8242 }
8243
8244 Result
8245 visitBinaryOperator(OverloadedOperatorKind OO, ArrayRef<Expr *> Args,
8246 Subobject Subobj,
8247 OverloadCandidateSet *SpaceshipCandidates = nullptr) {
8248 // Note that there is no need to consider rewritten candidates here if
8249 // we've already found there is no viable 'operator<=>' candidate (and are
8250 // considering synthesizing a '<=>' from '==' and '<').
8251 OverloadCandidateSet CandidateSet(
8252 FD->getLocation(), OverloadCandidateSet::CSK_Operator,
8253 OverloadCandidateSet::OperatorRewriteInfo(
8254 OO, FD->getLocation(),
8255 /*AllowRewrittenCandidates=*/!SpaceshipCandidates));
8256
8257 /// C++2a [class.compare.default]p1 [P2002R0]:
8258 /// [...] the defaulted function itself is never a candidate for overload
8259 /// resolution [...]
8260 CandidateSet.exclude(F: FD);
8261
8262 if (Args[0]->getType()->isOverloadableType())
8263 S.LookupOverloadedBinOp(CandidateSet, Op: OO, Fns, Args);
8264 else
8265 // FIXME: We determine whether this is a valid expression by checking to
8266 // see if there's a viable builtin operator candidate for it. That isn't
8267 // really what the rules ask us to do, but should give the right results.
8268 S.AddBuiltinOperatorCandidates(Op: OO, OpLoc: FD->getLocation(), Args, CandidateSet);
8269
8270 Result R;
8271
8272 OverloadCandidateSet::iterator Best;
8273 switch (CandidateSet.BestViableFunction(S, Loc: FD->getLocation(), Best)) {
8274 case OR_Success: {
8275 // C++2a [class.compare.secondary]p2 [P2002R0]:
8276 // The operator function [...] is defined as deleted if [...] the
8277 // candidate selected by overload resolution is not a rewritten
8278 // candidate.
8279 if ((DCK == DefaultedComparisonKind::NotEqual ||
8280 DCK == DefaultedComparisonKind::Relational) &&
8281 !Best->RewriteKind) {
8282 if (Diagnose == ExplainDeleted) {
8283 if (Best->Function) {
8284 S.Diag(Loc: Best->Function->getLocation(),
8285 DiagID: diag::note_defaulted_comparison_not_rewritten_callee)
8286 << FD;
8287 } else {
8288 assert(Best->Conversions.size() == 2 &&
8289 Best->Conversions[0].isUserDefined() &&
8290 "non-user-defined conversion from class to built-in "
8291 "comparison");
8292 S.Diag(Loc: Best->Conversions[0]
8293 .UserDefined.FoundConversionFunction.getDecl()
8294 ->getLocation(),
8295 DiagID: diag::note_defaulted_comparison_not_rewritten_conversion)
8296 << FD;
8297 }
8298 }
8299 return Result::deleted();
8300 }
8301
8302 // Throughout C++2a [class.compare]: if overload resolution does not
8303 // result in a usable function, the candidate function is defined as
8304 // deleted. This requires that we selected an accessible function.
8305 //
8306 // Note that this only considers the access of the function when named
8307 // within the type of the subobject, and not the access path for any
8308 // derived-to-base conversion.
8309 CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
8310 if (ArgClass && Best->FoundDecl.getDecl() &&
8311 Best->FoundDecl.getDecl()->isCXXClassMember()) {
8312 QualType ObjectType = Subobj.Kind == Subobject::Member
8313 ? Args[0]->getType()
8314 : S.Context.getCanonicalTagType(TD: RD);
8315 if (!S.isMemberAccessibleForDeletion(
8316 NamingClass: ArgClass, Found: Best->FoundDecl, ObjectType, Loc: Subobj.Loc,
8317 Diag: Diagnose == ExplainDeleted
8318 ? S.PDiag(DiagID: diag::note_defaulted_comparison_inaccessible)
8319 << FD << Subobj.Kind << Subobj.Decl
8320 : S.PDiag()))
8321 return Result::deleted();
8322 }
8323
8324 bool NeedsDeducing =
8325 OO == OO_Spaceship && FD->getReturnType()->isUndeducedAutoType();
8326
8327 if (FunctionDecl *BestFD = Best->Function) {
8328 // C++2a [class.compare.default]p3 [P2002R0]:
8329 // A defaulted comparison function is constexpr-compatible if
8330 // [...] no overlod resolution performed [...] results in a
8331 // non-constexpr function.
8332 assert(!BestFD->isDeleted() && "wrong overload resolution result");
8333 // If it's not constexpr, explain why not.
8334 if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
8335 if (Subobj.Kind != Subobject::CompleteObject)
8336 S.Diag(Loc: Subobj.Loc, DiagID: diag::note_defaulted_comparison_not_constexpr)
8337 << Subobj.Kind << Subobj.Decl;
8338 S.Diag(Loc: BestFD->getLocation(),
8339 DiagID: diag::note_defaulted_comparison_not_constexpr_here);
8340 // Bail out after explaining; we don't want any more notes.
8341 return Result::deleted();
8342 }
8343 R.Constexpr &= BestFD->isConstexpr();
8344
8345 if (NeedsDeducing) {
8346 // If any callee has an undeduced return type, deduce it now.
8347 // FIXME: It's not clear how a failure here should be handled. For
8348 // now, we produce an eager diagnostic, because that is forward
8349 // compatible with most (all?) other reasonable options.
8350 if (BestFD->getReturnType()->isUndeducedType() &&
8351 S.DeduceReturnType(FD: BestFD, Loc: FD->getLocation(),
8352 /*Diagnose=*/false)) {
8353 // Don't produce a duplicate error when asked to explain why the
8354 // comparison is deleted: we diagnosed that when initially checking
8355 // the defaulted operator.
8356 if (Diagnose == NoDiagnostics) {
8357 S.Diag(
8358 Loc: FD->getLocation(),
8359 DiagID: diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
8360 << Subobj.Kind << Subobj.Decl;
8361 S.Diag(
8362 Loc: Subobj.Loc,
8363 DiagID: diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
8364 << Subobj.Kind << Subobj.Decl;
8365 S.Diag(Loc: BestFD->getLocation(),
8366 DiagID: diag::note_defaulted_comparison_cannot_deduce_callee)
8367 << Subobj.Kind << Subobj.Decl;
8368 }
8369 return Result::deleted();
8370 }
8371 auto *Info = S.Context.CompCategories.lookupInfoForType(
8372 Ty: BestFD->getCallResultType());
8373 if (!Info) {
8374 if (Diagnose == ExplainDeleted) {
8375 S.Diag(Loc: Subobj.Loc, DiagID: diag::note_defaulted_comparison_cannot_deduce)
8376 << Subobj.Kind << Subobj.Decl
8377 << BestFD->getCallResultType().withoutLocalFastQualifiers();
8378 S.Diag(Loc: BestFD->getLocation(),
8379 DiagID: diag::note_defaulted_comparison_cannot_deduce_callee)
8380 << Subobj.Kind << Subobj.Decl;
8381 }
8382 return Result::deleted();
8383 }
8384 R.Category = Info->Kind;
8385 }
8386 } else {
8387 QualType T = Best->BuiltinParamTypes[0];
8388 assert(T == Best->BuiltinParamTypes[1] &&
8389 "builtin comparison for different types?");
8390 assert(Best->BuiltinParamTypes[2].isNull() &&
8391 "invalid builtin comparison");
8392
8393 // FIXME: If the type we deduced is a vector type, we mark the
8394 // comparison as deleted because we don't yet support this.
8395 if (isa<VectorType>(Val: T)) {
8396 if (Diagnose == ExplainDeleted) {
8397 S.Diag(Loc: FD->getLocation(),
8398 DiagID: diag::note_defaulted_comparison_vector_types)
8399 << FD;
8400 S.Diag(Loc: Subobj.Decl->getLocation(), DiagID: diag::note_declared_at);
8401 }
8402 return Result::deleted();
8403 }
8404
8405 if (NeedsDeducing) {
8406 std::optional<ComparisonCategoryType> Cat =
8407 getComparisonCategoryForBuiltinCmp(T);
8408 assert(Cat && "no category for builtin comparison?");
8409 R.Category = *Cat;
8410 }
8411 }
8412
8413 // Note that we might be rewriting to a different operator. That call is
8414 // not considered until we come to actually build the comparison function.
8415 break;
8416 }
8417
8418 case OR_Ambiguous:
8419 if (Diagnose == ExplainDeleted) {
8420 unsigned Kind = 0;
8421 if (FD->getOverloadedOperator() == OO_Spaceship && OO != OO_Spaceship)
8422 Kind = OO == OO_EqualEqual ? 1 : 2;
8423 CandidateSet.NoteCandidates(
8424 PA: PartialDiagnosticAt(
8425 Subobj.Loc, S.PDiag(DiagID: diag::note_defaulted_comparison_ambiguous)
8426 << FD << Kind << Subobj.Kind << Subobj.Decl),
8427 S, OCD: OCD_AmbiguousCandidates, Args);
8428 }
8429 R = Result::deleted();
8430 break;
8431
8432 case OR_Deleted:
8433 if (Diagnose == ExplainDeleted) {
8434 if ((DCK == DefaultedComparisonKind::NotEqual ||
8435 DCK == DefaultedComparisonKind::Relational) &&
8436 !Best->RewriteKind) {
8437 S.Diag(Loc: Best->Function->getLocation(),
8438 DiagID: diag::note_defaulted_comparison_not_rewritten_callee)
8439 << FD;
8440 } else {
8441 S.Diag(Loc: Subobj.Loc,
8442 DiagID: diag::note_defaulted_comparison_calls_deleted)
8443 << FD << Subobj.Kind << Subobj.Decl;
8444 S.NoteDeletedFunction(FD: Best->Function);
8445 }
8446 }
8447 R = Result::deleted();
8448 break;
8449
8450 case OR_No_Viable_Function:
8451 // If there's no usable candidate, we're done unless we can rewrite a
8452 // '<=>' in terms of '==' and '<'.
8453 if (OO == OO_Spaceship &&
8454 S.Context.CompCategories.lookupInfoForType(Ty: FD->getReturnType())) {
8455 // For any kind of comparison category return type, we need a usable
8456 // '==' and a usable '<'.
8457 if (!R.add(R: visitBinaryOperator(OO: OO_EqualEqual, Args, Subobj,
8458 SpaceshipCandidates: &CandidateSet)))
8459 R.add(R: visitBinaryOperator(OO: OO_Less, Args, Subobj, SpaceshipCandidates: &CandidateSet));
8460 break;
8461 }
8462
8463 if (Diagnose == ExplainDeleted) {
8464 S.Diag(Loc: Subobj.Loc, DiagID: diag::note_defaulted_comparison_no_viable_function)
8465 << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
8466 << Subobj.Kind << Subobj.Decl;
8467
8468 // For a three-way comparison, list both the candidates for the
8469 // original operator and the candidates for the synthesized operator.
8470 if (SpaceshipCandidates) {
8471 SpaceshipCandidates->NoteCandidates(
8472 S, Args,
8473 Cands: SpaceshipCandidates->CompleteCandidates(S, OCD: OCD_AllCandidates,
8474 Args, OpLoc: FD->getLocation()));
8475 S.Diag(Loc: Subobj.Loc,
8476 DiagID: diag::note_defaulted_comparison_no_viable_function_synthesized)
8477 << (OO == OO_EqualEqual ? 0 : 1);
8478 }
8479
8480 CandidateSet.NoteCandidates(
8481 S, Args,
8482 Cands: CandidateSet.CompleteCandidates(S, OCD: OCD_AllCandidates, Args,
8483 OpLoc: FD->getLocation()));
8484 }
8485 R = Result::deleted();
8486 break;
8487 }
8488
8489 return R;
8490 }
8491};
8492
8493/// A list of statements.
8494struct StmtListResult {
8495 bool IsInvalid = false;
8496 llvm::SmallVector<Stmt*, 16> Stmts;
8497
8498 bool add(const StmtResult &S) {
8499 IsInvalid |= S.isInvalid();
8500 if (IsInvalid)
8501 return true;
8502 Stmts.push_back(Elt: S.get());
8503 return false;
8504 }
8505};
8506
8507/// A visitor over the notional body of a defaulted comparison that synthesizes
8508/// the actual body.
8509class DefaultedComparisonSynthesizer
8510 : public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
8511 StmtListResult, StmtResult,
8512 std::pair<ExprResult, ExprResult>> {
8513 SourceLocation Loc;
8514 unsigned ArrayDepth = 0;
8515
8516public:
8517 using Base = DefaultedComparisonVisitor;
8518 using ExprPair = std::pair<ExprResult, ExprResult>;
8519
8520 friend Base;
8521
8522 DefaultedComparisonSynthesizer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
8523 DefaultedComparisonKind DCK,
8524 SourceLocation BodyLoc)
8525 : Base(S, RD, FD, DCK), Loc(BodyLoc) {}
8526
8527 /// Build a suitable function body for this defaulted comparison operator.
8528 StmtResult build() {
8529 Sema::CompoundScopeRAII CompoundScope(S);
8530
8531 StmtListResult Stmts = visit();
8532 if (Stmts.IsInvalid)
8533 return StmtError();
8534
8535 ExprResult RetVal;
8536 switch (DCK) {
8537 case DefaultedComparisonKind::None:
8538 llvm_unreachable("not a defaulted comparison");
8539
8540 case DefaultedComparisonKind::Equal: {
8541 // C++2a [class.eq]p3:
8542 // [...] compar[e] the corresponding elements [...] until the first
8543 // index i where xi == yi yields [...] false. If no such index exists,
8544 // V is true. Otherwise, V is false.
8545 //
8546 // Join the comparisons with '&&'s and return the result. Use a right
8547 // fold (traversing the conditions right-to-left), because that
8548 // short-circuits more naturally.
8549 auto OldStmts = std::move(Stmts.Stmts);
8550 Stmts.Stmts.clear();
8551 ExprResult CmpSoFar;
8552 // Finish a particular comparison chain.
8553 auto FinishCmp = [&] {
8554 if (Expr *Prior = CmpSoFar.get()) {
8555 // Convert the last expression to 'return ...;'
8556 if (RetVal.isUnset() && Stmts.Stmts.empty())
8557 RetVal = CmpSoFar;
8558 // Convert any prior comparison to 'if (!(...)) return false;'
8559 else if (Stmts.add(S: buildIfNotCondReturnFalse(Cond: Prior)))
8560 return true;
8561 CmpSoFar = ExprResult();
8562 }
8563 return false;
8564 };
8565 for (Stmt *EAsStmt : llvm::reverse(C&: OldStmts)) {
8566 Expr *E = dyn_cast<Expr>(Val: EAsStmt);
8567 if (!E) {
8568 // Found an array comparison.
8569 if (FinishCmp() || Stmts.add(S: EAsStmt))
8570 return StmtError();
8571 continue;
8572 }
8573
8574 if (CmpSoFar.isUnset()) {
8575 CmpSoFar = E;
8576 continue;
8577 }
8578 CmpSoFar = S.CreateBuiltinBinOp(OpLoc: Loc, Opc: BO_LAnd, LHSExpr: E, RHSExpr: CmpSoFar.get());
8579 if (CmpSoFar.isInvalid())
8580 return StmtError();
8581 }
8582 if (FinishCmp())
8583 return StmtError();
8584 std::reverse(first: Stmts.Stmts.begin(), last: Stmts.Stmts.end());
8585 // If no such index exists, V is true.
8586 if (RetVal.isUnset())
8587 RetVal = S.ActOnCXXBoolLiteral(OpLoc: Loc, Kind: tok::kw_true);
8588 break;
8589 }
8590
8591 case DefaultedComparisonKind::ThreeWay: {
8592 // Per C++2a [class.spaceship]p3, as a fallback add:
8593 // return static_cast<R>(std::strong_ordering::equal);
8594 QualType StrongOrdering = S.CheckComparisonCategoryType(
8595 Kind: ComparisonCategoryType::StrongOrdering, Loc,
8596 Usage: Sema::ComparisonCategoryUsage::DefaultedOperator);
8597 if (StrongOrdering.isNull())
8598 return StmtError();
8599 VarDecl *EqualVD = S.Context.CompCategories.getInfoForType(Ty: StrongOrdering)
8600 .getValueInfo(ValueKind: ComparisonCategoryResult::Equal)
8601 ->VD;
8602 RetVal = getDecl(VD: EqualVD);
8603 if (RetVal.isInvalid())
8604 return StmtError();
8605 RetVal = buildStaticCastToR(E: RetVal.get());
8606 break;
8607 }
8608
8609 case DefaultedComparisonKind::NotEqual:
8610 case DefaultedComparisonKind::Relational:
8611 RetVal = cast<Expr>(Val: Stmts.Stmts.pop_back_val());
8612 break;
8613 }
8614
8615 // Build the final return statement.
8616 if (RetVal.isInvalid())
8617 return StmtError();
8618 StmtResult ReturnStmt = S.BuildReturnStmt(ReturnLoc: Loc, RetValExp: RetVal.get());
8619 if (ReturnStmt.isInvalid())
8620 return StmtError();
8621 Stmts.Stmts.push_back(Elt: ReturnStmt.get());
8622
8623 return S.ActOnCompoundStmt(L: Loc, R: Loc, Elts: Stmts.Stmts, /*IsStmtExpr=*/isStmtExpr: false);
8624 }
8625
8626private:
8627 ExprResult getDecl(ValueDecl *VD) {
8628 return S.BuildDeclarationNameExpr(
8629 SS: CXXScopeSpec(), NameInfo: DeclarationNameInfo(VD->getDeclName(), Loc), D: VD);
8630 }
8631
8632 ExprResult getParam(unsigned I) {
8633 ParmVarDecl *PD = FD->getParamDecl(i: I);
8634 return getDecl(VD: PD);
8635 }
8636
8637 ExprPair getCompleteObject() {
8638 unsigned Param = 0;
8639 ExprResult LHS;
8640 if (const auto *MD = dyn_cast<CXXMethodDecl>(Val: FD);
8641 MD && MD->isImplicitObjectMemberFunction()) {
8642 // LHS is '*this'.
8643 LHS = S.ActOnCXXThis(Loc);
8644 if (!LHS.isInvalid())
8645 LHS = S.CreateBuiltinUnaryOp(OpLoc: Loc, Opc: UO_Deref, InputExpr: LHS.get());
8646 } else {
8647 LHS = getParam(I: Param++);
8648 }
8649 ExprResult RHS = getParam(I: Param++);
8650 assert(Param == FD->getNumParams());
8651 return {LHS, RHS};
8652 }
8653
8654 ExprPair getBase(CXXBaseSpecifier *Base) {
8655 ExprPair Obj = getCompleteObject();
8656 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8657 return {ExprError(), ExprError()};
8658 CXXCastPath Path = {Base};
8659 const auto CastToBase = [&](Expr *E) {
8660 QualType ToType = S.Context.getQualifiedType(
8661 T: Base->getType(), Qs: E->getType().getQualifiers());
8662 return S.ImpCastExprToType(E, Type: ToType, CK: CK_DerivedToBase, VK: VK_LValue, BasePath: &Path);
8663 };
8664 return {CastToBase(Obj.first.get()), CastToBase(Obj.second.get())};
8665 }
8666
8667 ExprPair getField(FieldDecl *Field) {
8668 ExprPair Obj = getCompleteObject();
8669 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8670 return {ExprError(), ExprError()};
8671
8672 DeclAccessPair Found = DeclAccessPair::make(D: Field, AS: Field->getAccess());
8673 DeclarationNameInfo NameInfo(Field->getDeclName(), Loc);
8674 return {S.BuildFieldReferenceExpr(BaseExpr: Obj.first.get(), /*IsArrow=*/false, OpLoc: Loc,
8675 SS: CXXScopeSpec(), Field, FoundDecl: Found, MemberNameInfo: NameInfo),
8676 S.BuildFieldReferenceExpr(BaseExpr: Obj.second.get(), /*IsArrow=*/false, OpLoc: Loc,
8677 SS: CXXScopeSpec(), Field, FoundDecl: Found, MemberNameInfo: NameInfo)};
8678 }
8679
8680 // FIXME: When expanding a subobject, register a note in the code synthesis
8681 // stack to say which subobject we're comparing.
8682
8683 StmtResult buildIfNotCondReturnFalse(ExprResult Cond) {
8684 if (Cond.isInvalid())
8685 return StmtError();
8686
8687 ExprResult NotCond = S.CreateBuiltinUnaryOp(OpLoc: Loc, Opc: UO_LNot, InputExpr: Cond.get());
8688 if (NotCond.isInvalid())
8689 return StmtError();
8690
8691 ExprResult False = S.ActOnCXXBoolLiteral(OpLoc: Loc, Kind: tok::kw_false);
8692 assert(!False.isInvalid() && "should never fail");
8693 StmtResult ReturnFalse = S.BuildReturnStmt(ReturnLoc: Loc, RetValExp: False.get());
8694 if (ReturnFalse.isInvalid())
8695 return StmtError();
8696
8697 return S.ActOnIfStmt(IfLoc: Loc, StatementKind: IfStatementKind::Ordinary, LParenLoc: Loc, InitStmt: nullptr,
8698 Cond: S.ActOnCondition(S: nullptr, Loc, SubExpr: NotCond.get(),
8699 CK: Sema::ConditionKind::Boolean),
8700 RParenLoc: Loc, ThenVal: ReturnFalse.get(), ElseLoc: SourceLocation(), ElseVal: nullptr);
8701 }
8702
8703 StmtResult visitSubobjectArray(QualType Type, llvm::APInt Size,
8704 ExprPair Subobj) {
8705 QualType SizeType = S.Context.getSizeType();
8706 Size = Size.zextOrTrunc(width: S.Context.getTypeSize(T: SizeType));
8707
8708 // Build 'size_t i$n = 0'.
8709 IdentifierInfo *IterationVarName = nullptr;
8710 {
8711 SmallString<8> Str;
8712 llvm::raw_svector_ostream OS(Str);
8713 OS << "i" << ArrayDepth;
8714 IterationVarName = &S.Context.Idents.get(Name: OS.str());
8715 }
8716 VarDecl *IterationVar = VarDecl::Create(
8717 C&: S.Context, DC: S.CurContext, StartLoc: Loc, IdLoc: Loc, Id: IterationVarName, T: SizeType,
8718 TInfo: S.Context.getTrivialTypeSourceInfo(T: SizeType, Loc), S: SC_None);
8719 llvm::APInt Zero(S.Context.getTypeSize(T: SizeType), 0);
8720 IterationVar->setInit(
8721 IntegerLiteral::Create(C: S.Context, V: Zero, type: SizeType, l: Loc));
8722 Stmt *Init = new (S.Context) DeclStmt(DeclGroupRef(IterationVar), Loc, Loc);
8723
8724 auto IterRef = [&] {
8725 ExprResult Ref = S.BuildDeclarationNameExpr(
8726 SS: CXXScopeSpec(), NameInfo: DeclarationNameInfo(IterationVarName, Loc),
8727 D: IterationVar);
8728 assert(!Ref.isInvalid() && "can't reference our own variable?");
8729 return Ref.get();
8730 };
8731
8732 // Build 'i$n != Size'.
8733 ExprResult Cond = S.CreateBuiltinBinOp(
8734 OpLoc: Loc, Opc: BO_NE, LHSExpr: IterRef(),
8735 RHSExpr: IntegerLiteral::Create(C: S.Context, V: Size, type: SizeType, l: Loc));
8736 assert(!Cond.isInvalid() && "should never fail");
8737
8738 // Build '++i$n'.
8739 ExprResult Inc = S.CreateBuiltinUnaryOp(OpLoc: Loc, Opc: UO_PreInc, InputExpr: IterRef());
8740 assert(!Inc.isInvalid() && "should never fail");
8741
8742 // Build 'a[i$n]' and 'b[i$n]'.
8743 auto Index = [&](ExprResult E) {
8744 if (E.isInvalid())
8745 return ExprError();
8746 return S.CreateBuiltinArraySubscriptExpr(Base: E.get(), LLoc: Loc, Idx: IterRef(), RLoc: Loc);
8747 };
8748 Subobj.first = Index(Subobj.first);
8749 Subobj.second = Index(Subobj.second);
8750
8751 // Compare the array elements.
8752 ++ArrayDepth;
8753 StmtResult Substmt = visitSubobject(Type, Subobj);
8754 --ArrayDepth;
8755
8756 if (Substmt.isInvalid())
8757 return StmtError();
8758
8759 // For the inner level of an 'operator==', build 'if (!cmp) return false;'.
8760 // For outer levels or for an 'operator<=>' we already have a suitable
8761 // statement that returns as necessary.
8762 if (Expr *ElemCmp = dyn_cast<Expr>(Val: Substmt.get())) {
8763 assert(DCK == DefaultedComparisonKind::Equal &&
8764 "should have non-expression statement");
8765 Substmt = buildIfNotCondReturnFalse(Cond: ElemCmp);
8766 if (Substmt.isInvalid())
8767 return StmtError();
8768 }
8769
8770 // Build 'for (...) ...'
8771 return S.ActOnForStmt(ForLoc: Loc, LParenLoc: Loc, First: Init,
8772 Second: S.ActOnCondition(S: nullptr, Loc, SubExpr: Cond.get(),
8773 CK: Sema::ConditionKind::Boolean),
8774 Third: S.MakeFullDiscardedValueExpr(Arg: Inc.get()), RParenLoc: Loc,
8775 Body: Substmt.get());
8776 }
8777
8778 StmtResult visitExpandedSubobject(QualType Type, ExprPair Obj) {
8779 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8780 return StmtError();
8781
8782 OverloadedOperatorKind OO = FD->getOverloadedOperator();
8783 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(OO);
8784 ExprResult Op;
8785 if (Type->isOverloadableType())
8786 Op = S.CreateOverloadedBinOp(OpLoc: Loc, Opc, Fns, LHS: Obj.first.get(),
8787 RHS: Obj.second.get(), /*PerformADL=*/RequiresADL: true,
8788 /*AllowRewrittenCandidates=*/true, DefaultedFn: FD);
8789 else
8790 Op = S.CreateBuiltinBinOp(OpLoc: Loc, Opc, LHSExpr: Obj.first.get(), RHSExpr: Obj.second.get());
8791 if (Op.isInvalid())
8792 return StmtError();
8793
8794 switch (DCK) {
8795 case DefaultedComparisonKind::None:
8796 llvm_unreachable("not a defaulted comparison");
8797
8798 case DefaultedComparisonKind::Equal:
8799 // Per C++2a [class.eq]p2, each comparison is individually contextually
8800 // converted to bool.
8801 Op = S.PerformContextuallyConvertToBool(From: Op.get());
8802 if (Op.isInvalid())
8803 return StmtError();
8804 return Op.get();
8805
8806 case DefaultedComparisonKind::ThreeWay: {
8807 // Per C++2a [class.spaceship]p3, form:
8808 // if (R cmp = static_cast<R>(op); cmp != 0)
8809 // return cmp;
8810 QualType R = FD->getReturnType();
8811 Op = buildStaticCastToR(E: Op.get());
8812 if (Op.isInvalid())
8813 return StmtError();
8814
8815 // R cmp = ...;
8816 IdentifierInfo *Name = &S.Context.Idents.get(Name: "cmp");
8817 VarDecl *VD =
8818 VarDecl::Create(C&: S.Context, DC: S.CurContext, StartLoc: Loc, IdLoc: Loc, Id: Name, T: R,
8819 TInfo: S.Context.getTrivialTypeSourceInfo(T: R, Loc), S: SC_None);
8820 S.AddInitializerToDecl(dcl: VD, init: Op.get(), /*DirectInit=*/false);
8821 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(VD), Loc, Loc);
8822
8823 // cmp != 0
8824 ExprResult VDRef = getDecl(VD);
8825 if (VDRef.isInvalid())
8826 return StmtError();
8827 llvm::APInt ZeroVal(S.Context.getIntWidth(T: S.Context.IntTy), 0);
8828 Expr *Zero =
8829 IntegerLiteral::Create(C: S.Context, V: ZeroVal, type: S.Context.IntTy, l: Loc);
8830 ExprResult Comp;
8831 if (VDRef.get()->getType()->isOverloadableType())
8832 Comp = S.CreateOverloadedBinOp(OpLoc: Loc, Opc: BO_NE, Fns, LHS: VDRef.get(), RHS: Zero, RequiresADL: true,
8833 AllowRewrittenCandidates: true, DefaultedFn: FD);
8834 else
8835 Comp = S.CreateBuiltinBinOp(OpLoc: Loc, Opc: BO_NE, LHSExpr: VDRef.get(), RHSExpr: Zero);
8836 if (Comp.isInvalid())
8837 return StmtError();
8838 Sema::ConditionResult Cond = S.ActOnCondition(
8839 S: nullptr, Loc, SubExpr: Comp.get(), CK: Sema::ConditionKind::Boolean);
8840 if (Cond.isInvalid())
8841 return StmtError();
8842
8843 // return cmp;
8844 VDRef = getDecl(VD);
8845 if (VDRef.isInvalid())
8846 return StmtError();
8847 StmtResult ReturnStmt = S.BuildReturnStmt(ReturnLoc: Loc, RetValExp: VDRef.get());
8848 if (ReturnStmt.isInvalid())
8849 return StmtError();
8850
8851 // if (...)
8852 return S.ActOnIfStmt(IfLoc: Loc, StatementKind: IfStatementKind::Ordinary, LParenLoc: Loc, InitStmt, Cond,
8853 RParenLoc: Loc, ThenVal: ReturnStmt.get(),
8854 /*ElseLoc=*/SourceLocation(), /*Else=*/ElseVal: nullptr);
8855 }
8856
8857 case DefaultedComparisonKind::NotEqual:
8858 case DefaultedComparisonKind::Relational:
8859 // C++2a [class.compare.secondary]p2:
8860 // Otherwise, the operator function yields x @ y.
8861 return Op.get();
8862 }
8863 llvm_unreachable("");
8864 }
8865
8866 /// Build "static_cast<R>(E)".
8867 ExprResult buildStaticCastToR(Expr *E) {
8868 QualType R = FD->getReturnType();
8869 assert(!R->isUndeducedType() && "type should have been deduced already");
8870
8871 // Don't bother forming a no-op cast in the common case.
8872 if (E->isPRValue() && S.Context.hasSameType(T1: E->getType(), T2: R))
8873 return E;
8874 return S.BuildCXXNamedCast(OpLoc: Loc, Kind: tok::kw_static_cast,
8875 Ty: S.Context.getTrivialTypeSourceInfo(T: R, Loc), E,
8876 AngleBrackets: SourceRange(Loc, Loc), Parens: SourceRange(Loc, Loc));
8877 }
8878};
8879}
8880
8881/// Perform the unqualified lookups that might be needed to form a defaulted
8882/// comparison function for the given operator.
8883static void lookupOperatorsForDefaultedComparison(Sema &Self, Scope *S,
8884 UnresolvedSetImpl &Operators,
8885 OverloadedOperatorKind Op) {
8886 auto Lookup = [&](OverloadedOperatorKind OO) {
8887 Self.LookupOverloadedOperatorName(Op: OO, S, Functions&: Operators);
8888 };
8889
8890 // Every defaulted operator looks up itself.
8891 Lookup(Op);
8892 // ... and the rewritten form of itself, if any.
8893 if (OverloadedOperatorKind ExtraOp = getRewrittenOverloadedOperator(Kind: Op))
8894 Lookup(ExtraOp);
8895
8896 // For 'operator<=>', we also form a 'cmp != 0' expression, and might
8897 // synthesize a three-way comparison from '<' and '=='. In a dependent
8898 // context, we also need to look up '==' in case we implicitly declare a
8899 // defaulted 'operator=='.
8900 if (Op == OO_Spaceship) {
8901 Lookup(OO_ExclaimEqual);
8902 Lookup(OO_Less);
8903 Lookup(OO_EqualEqual);
8904 }
8905}
8906
8907bool Sema::CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *FD,
8908 DefaultedComparisonKind DCK) {
8909 assert(DCK != DefaultedComparisonKind::None && "not a defaulted comparison");
8910
8911 // Perform any unqualified lookups we're going to need to default this
8912 // function.
8913 if (S) {
8914 UnresolvedSet<32> Operators;
8915 lookupOperatorsForDefaultedComparison(Self&: *this, S, Operators,
8916 Op: FD->getOverloadedOperator());
8917 FD->setDefaultedOrDeletedInfo(
8918 FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
8919 Context, Lookups: Operators.pairs()));
8920 }
8921
8922 // C++2a [class.compare.default]p1:
8923 // A defaulted comparison operator function for some class C shall be a
8924 // non-template function declared in the member-specification of C that is
8925 // -- a non-static const non-volatile member of C having one parameter of
8926 // type const C& and either no ref-qualifier or the ref-qualifier &, or
8927 // -- a friend of C having two parameters of type const C& or two
8928 // parameters of type C.
8929
8930 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Val: FD->getLexicalDeclContext());
8931 bool IsMethod = isa<CXXMethodDecl>(Val: FD);
8932 if (IsMethod) {
8933 auto *MD = cast<CXXMethodDecl>(Val: FD);
8934 assert(!MD->isStatic() && "comparison function cannot be a static member");
8935
8936 if (MD->getRefQualifier() == RQ_RValue) {
8937 Diag(Loc: MD->getLocation(), DiagID: diag::err_ref_qualifier_comparison_operator);
8938
8939 // Remove the ref qualifier to recover.
8940 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8941 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8942 EPI.RefQualifier = RQ_None;
8943 MD->setType(Context.getFunctionType(ResultTy: FPT->getReturnType(),
8944 Args: FPT->getParamTypes(), EPI));
8945 }
8946
8947 // If we're out-of-class, this is the class we're comparing.
8948 if (!RD)
8949 RD = MD->getParent();
8950 QualType T = MD->getFunctionObjectParameterReferenceType();
8951 if (!T.getNonReferenceType().isConstQualified() &&
8952 (MD->isImplicitObjectMemberFunction() || T->isLValueReferenceType())) {
8953 SourceLocation Loc, InsertLoc;
8954 if (MD->isExplicitObjectMemberFunction()) {
8955 Loc = MD->getParamDecl(i: 0)->getBeginLoc();
8956 InsertLoc = getLocForEndOfToken(
8957 Loc: MD->getParamDecl(i: 0)->getExplicitObjectParamThisLoc());
8958 } else {
8959 Loc = MD->getLocation();
8960 if (FunctionTypeLoc Loc = MD->getFunctionTypeLoc())
8961 InsertLoc = Loc.getRParenLoc();
8962 }
8963 // Don't diagnose an implicit 'operator=='; we will have diagnosed the
8964 // corresponding defaulted 'operator<=>' already.
8965 if (!MD->isImplicit()) {
8966 Diag(Loc, DiagID: diag::err_defaulted_comparison_non_const)
8967 << (int)DCK << FixItHint::CreateInsertion(InsertionLoc: InsertLoc, Code: " const");
8968 }
8969
8970 // Add the 'const' to the type to recover.
8971 if (MD->isExplicitObjectMemberFunction()) {
8972 assert(T->isLValueReferenceType());
8973 MD->getParamDecl(i: 0)->setType(Context.getLValueReferenceType(
8974 T: T.getNonReferenceType().withConst()));
8975 } else {
8976 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8977 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8978 EPI.TypeQuals.addConst();
8979 MD->setType(Context.getFunctionType(ResultTy: FPT->getReturnType(),
8980 Args: FPT->getParamTypes(), EPI));
8981 }
8982 }
8983
8984 if (MD->isVolatile()) {
8985 Diag(Loc: MD->getLocation(), DiagID: diag::err_volatile_comparison_operator);
8986
8987 // Remove the 'volatile' from the type to recover.
8988 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8989 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8990 EPI.TypeQuals.removeVolatile();
8991 MD->setType(Context.getFunctionType(ResultTy: FPT->getReturnType(),
8992 Args: FPT->getParamTypes(), EPI));
8993 }
8994 }
8995
8996 if ((FD->getNumParams() -
8997 (unsigned)FD->hasCXXExplicitFunctionObjectParameter()) !=
8998 (IsMethod ? 1 : 2)) {
8999 // Let's not worry about using a variadic template pack here -- who would do
9000 // such a thing?
9001 Diag(Loc: FD->getLocation(), DiagID: diag::err_defaulted_comparison_num_args)
9002 << int(IsMethod) << int(DCK);
9003 return true;
9004 }
9005
9006 const ParmVarDecl *KnownParm = nullptr;
9007 for (const ParmVarDecl *Param : FD->parameters()) {
9008 QualType ParmTy = Param->getType();
9009 if (!KnownParm) {
9010 auto CTy = ParmTy;
9011 // Is it `T const &`?
9012 bool Ok = !IsMethod || FD->hasCXXExplicitFunctionObjectParameter();
9013 QualType ExpectedTy;
9014 if (RD)
9015 ExpectedTy = Context.getCanonicalTagType(TD: RD);
9016 if (auto *Ref = CTy->getAs<LValueReferenceType>()) {
9017 CTy = Ref->getPointeeType();
9018 if (RD)
9019 ExpectedTy.addConst();
9020 Ok = true;
9021 }
9022
9023 // Is T a class?
9024 if (RD) {
9025 Ok &= RD->isDependentType() || Context.hasSameType(T1: CTy, T2: ExpectedTy);
9026 } else {
9027 RD = CTy->getAsCXXRecordDecl();
9028 Ok &= RD != nullptr;
9029 }
9030
9031 if (Ok) {
9032 KnownParm = Param;
9033 } else {
9034 // Don't diagnose an implicit 'operator=='; we will have diagnosed the
9035 // corresponding defaulted 'operator<=>' already.
9036 if (!FD->isImplicit()) {
9037 if (RD) {
9038 CanQualType PlainTy = Context.getCanonicalTagType(TD: RD);
9039 QualType RefTy =
9040 Context.getLValueReferenceType(T: PlainTy.withConst());
9041 Diag(Loc: FD->getLocation(), DiagID: diag::err_defaulted_comparison_param)
9042 << int(DCK) << ParmTy << RefTy << int(!IsMethod) << PlainTy
9043 << Param->getSourceRange();
9044 } else {
9045 assert(!IsMethod && "should know expected type for method");
9046 Diag(Loc: FD->getLocation(),
9047 DiagID: diag::err_defaulted_comparison_param_unknown)
9048 << int(DCK) << ParmTy << Param->getSourceRange();
9049 }
9050 }
9051 return true;
9052 }
9053 } else if (!Context.hasSameType(T1: KnownParm->getType(), T2: ParmTy)) {
9054 Diag(Loc: FD->getLocation(), DiagID: diag::err_defaulted_comparison_param_mismatch)
9055 << int(DCK) << KnownParm->getType() << KnownParm->getSourceRange()
9056 << ParmTy << Param->getSourceRange();
9057 return true;
9058 }
9059 }
9060
9061 assert(RD && "must have determined class");
9062 if (IsMethod) {
9063 } else if (isa<CXXRecordDecl>(Val: FD->getLexicalDeclContext())) {
9064 // In-class, must be a friend decl.
9065 assert(FD->getFriendObjectKind() && "expected a friend declaration");
9066 } else {
9067 // Out of class, require the defaulted comparison to be a friend (of a
9068 // complete type, per CWG2547).
9069 if (RequireCompleteType(Loc: FD->getLocation(), T: Context.getCanonicalTagType(TD: RD),
9070 DiagID: diag::err_defaulted_comparison_not_friend, Args: int(DCK),
9071 Args: int(1)))
9072 return true;
9073
9074 if (llvm::none_of(Range: RD->friends(), P: [&](const FriendDecl *F) {
9075 return declaresSameEntity(D1: F->getFriendDecl(), D2: FD);
9076 })) {
9077 Diag(Loc: FD->getLocation(), DiagID: diag::err_defaulted_comparison_not_friend)
9078 << int(DCK) << int(0) << RD;
9079 Diag(Loc: RD->getCanonicalDecl()->getLocation(), DiagID: diag::note_declared_at);
9080 return true;
9081 }
9082 }
9083
9084 // C++2a [class.eq]p1, [class.rel]p1:
9085 // A [defaulted comparison other than <=>] shall have a declared return
9086 // type bool.
9087 if (DCK != DefaultedComparisonKind::ThreeWay &&
9088 !FD->getDeclaredReturnType()->isDependentType() &&
9089 !Context.hasSameType(T1: FD->getDeclaredReturnType(), T2: Context.BoolTy)) {
9090 Diag(Loc: FD->getLocation(), DiagID: diag::err_defaulted_comparison_return_type_not_bool)
9091 << (int)DCK << FD->getDeclaredReturnType() << Context.BoolTy
9092 << FD->getReturnTypeSourceRange();
9093 return true;
9094 }
9095 // C++2a [class.spaceship]p2 [P2002R0]:
9096 // Let R be the declared return type [...]. If R is auto, [...]. Otherwise,
9097 // R shall not contain a placeholder type.
9098 if (QualType RT = FD->getDeclaredReturnType();
9099 DCK == DefaultedComparisonKind::ThreeWay &&
9100 RT->getContainedDeducedType() &&
9101 (!Context.hasSameType(T1: RT, T2: Context.getAutoDeductType()) ||
9102 RT->getContainedAutoType()->isConstrained())) {
9103 Diag(Loc: FD->getLocation(),
9104 DiagID: diag::err_defaulted_comparison_deduced_return_type_not_auto)
9105 << (int)DCK << FD->getDeclaredReturnType() << Context.AutoDeductTy
9106 << FD->getReturnTypeSourceRange();
9107 return true;
9108 }
9109
9110 // For a defaulted function in a dependent class, defer all remaining checks
9111 // until instantiation.
9112 if (RD->isDependentType())
9113 return false;
9114
9115 // Determine whether the function should be defined as deleted.
9116 DefaultedComparisonInfo Info =
9117 DefaultedComparisonAnalyzer(*this, RD, FD, DCK).visit();
9118
9119 bool First = FD == FD->getCanonicalDecl();
9120
9121 if (!First) {
9122 if (Info.Deleted) {
9123 // C++11 [dcl.fct.def.default]p4:
9124 // [For a] user-provided explicitly-defaulted function [...] if such a
9125 // function is implicitly defined as deleted, the program is ill-formed.
9126 //
9127 // This is really just a consequence of the general rule that you can
9128 // only delete a function on its first declaration.
9129 Diag(Loc: FD->getLocation(), DiagID: diag::err_non_first_default_compare_deletes)
9130 << FD->isImplicit() << (int)DCK;
9131 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
9132 DefaultedComparisonAnalyzer::ExplainDeleted)
9133 .visit();
9134 return true;
9135 }
9136 if (isa<CXXRecordDecl>(Val: FD->getLexicalDeclContext())) {
9137 // C++20 [class.compare.default]p1:
9138 // [...] A definition of a comparison operator as defaulted that appears
9139 // in a class shall be the first declaration of that function.
9140 Diag(Loc: FD->getLocation(), DiagID: diag::err_non_first_default_compare_in_class)
9141 << (int)DCK;
9142 Diag(Loc: FD->getCanonicalDecl()->getLocation(),
9143 DiagID: diag::note_previous_declaration);
9144 return true;
9145 }
9146 }
9147
9148 // If we want to delete the function, then do so; there's nothing else to
9149 // check in that case.
9150 if (Info.Deleted) {
9151 SetDeclDeleted(dcl: FD, DelLoc: FD->getLocation());
9152 if (!inTemplateInstantiation() && !FD->isImplicit()) {
9153 Diag(Loc: FD->getLocation(), DiagID: diag::warn_defaulted_comparison_deleted)
9154 << (int)DCK;
9155 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
9156 DefaultedComparisonAnalyzer::ExplainDeleted)
9157 .visit();
9158 if (FD->getDefaultLoc().isValid())
9159 Diag(Loc: FD->getDefaultLoc(), DiagID: diag::note_replace_equals_default_to_delete)
9160 << FixItHint::CreateReplacement(RemoveRange: FD->getDefaultLoc(), Code: "delete");
9161 }
9162 return false;
9163 }
9164
9165 // C++2a [class.spaceship]p2:
9166 // The return type is deduced as the common comparison type of R0, R1, ...
9167 if (DCK == DefaultedComparisonKind::ThreeWay &&
9168 FD->getDeclaredReturnType()->isUndeducedAutoType()) {
9169 SourceLocation RetLoc = FD->getReturnTypeSourceRange().getBegin();
9170 if (RetLoc.isInvalid())
9171 RetLoc = FD->getBeginLoc();
9172 // FIXME: Should we really care whether we have the complete type and the
9173 // 'enumerator' constants here? A forward declaration seems sufficient.
9174 QualType Cat = CheckComparisonCategoryType(
9175 Kind: Info.Category, Loc: RetLoc, Usage: ComparisonCategoryUsage::DefaultedOperator);
9176 if (Cat.isNull())
9177 return true;
9178 Context.adjustDeducedFunctionResultType(
9179 FD, ResultType: SubstAutoType(TypeWithAuto: FD->getDeclaredReturnType(), Replacement: Cat));
9180 }
9181
9182 // C++2a [dcl.fct.def.default]p3 [P2002R0]:
9183 // An explicitly-defaulted function that is not defined as deleted may be
9184 // declared constexpr or consteval only if it is constexpr-compatible.
9185 // C++2a [class.compare.default]p3 [P2002R0]:
9186 // A defaulted comparison function is constexpr-compatible if it satisfies
9187 // the requirements for a constexpr function [...]
9188 // The only relevant requirements are that the parameter and return types are
9189 // literal types. The remaining conditions are checked by the analyzer.
9190 //
9191 // We support P2448R2 in language modes earlier than C++23 as an extension.
9192 // The concept of constexpr-compatible was removed.
9193 // C++23 [dcl.fct.def.default]p3 [P2448R2]
9194 // A function explicitly defaulted on its first declaration is implicitly
9195 // inline, and is implicitly constexpr if it is constexpr-suitable.
9196 // C++23 [dcl.constexpr]p3
9197 // A function is constexpr-suitable if
9198 // - it is not a coroutine, and
9199 // - if the function is a constructor or destructor, its class does not
9200 // have any virtual base classes.
9201 if (FD->isConstexpr()) {
9202 if (!getLangOpts().CPlusPlus23 &&
9203 CheckConstexprReturnType(SemaRef&: *this, FD, Kind: CheckConstexprKind::Diagnose) &&
9204 CheckConstexprParameterTypes(SemaRef&: *this, FD, Kind: CheckConstexprKind::Diagnose) &&
9205 !Info.Constexpr) {
9206 Diag(Loc: FD->getBeginLoc(), DiagID: diag::err_defaulted_comparison_constexpr_mismatch)
9207 << FD->isImplicit() << (int)DCK << FD->isConsteval();
9208 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
9209 DefaultedComparisonAnalyzer::ExplainConstexpr)
9210 .visit();
9211 }
9212 }
9213
9214 // C++2a [dcl.fct.def.default]p3 [P2002R0]:
9215 // If a constexpr-compatible function is explicitly defaulted on its first
9216 // declaration, it is implicitly considered to be constexpr.
9217 // FIXME: Only applying this to the first declaration seems problematic, as
9218 // simple reorderings can affect the meaning of the program.
9219 if (First && !FD->isConstexpr() && Info.Constexpr)
9220 FD->setConstexprKind(ConstexprSpecKind::Constexpr);
9221
9222 // C++2a [except.spec]p3:
9223 // If a declaration of a function does not have a noexcept-specifier
9224 // [and] is defaulted on its first declaration, [...] the exception
9225 // specification is as specified below
9226 if (FD->getExceptionSpecType() == EST_None) {
9227 auto *FPT = FD->getType()->castAs<FunctionProtoType>();
9228 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
9229 EPI.ExceptionSpec.Type = EST_Unevaluated;
9230 EPI.ExceptionSpec.SourceDecl = FD;
9231 FD->setType(Context.getFunctionType(ResultTy: FPT->getReturnType(),
9232 Args: FPT->getParamTypes(), EPI));
9233 }
9234
9235 return false;
9236}
9237
9238void Sema::DeclareImplicitEqualityComparison(CXXRecordDecl *RD,
9239 FunctionDecl *Spaceship) {
9240 Sema::CodeSynthesisContext Ctx;
9241 Ctx.Kind = Sema::CodeSynthesisContext::DeclaringImplicitEqualityComparison;
9242 Ctx.PointOfInstantiation = Spaceship->getEndLoc();
9243 Ctx.Entity = Spaceship;
9244 pushCodeSynthesisContext(Ctx);
9245
9246 if (FunctionDecl *EqualEqual = SubstSpaceshipAsEqualEqual(RD, Spaceship))
9247 EqualEqual->setImplicit();
9248
9249 popCodeSynthesisContext();
9250}
9251
9252void Sema::DefineDefaultedComparison(SourceLocation UseLoc, FunctionDecl *FD,
9253 DefaultedComparisonKind DCK) {
9254 assert(FD->isDefaulted() && !FD->isDeleted() &&
9255 !FD->doesThisDeclarationHaveABody());
9256 if (FD->willHaveBody() || FD->isInvalidDecl())
9257 return;
9258
9259 SynthesizedFunctionScope Scope(*this, FD);
9260
9261 // Add a context note for diagnostics produced after this point.
9262 Scope.addContextNote(UseLoc);
9263
9264 {
9265 // Build and set up the function body.
9266 // The first parameter has type maybe-ref-to maybe-const T, use that to get
9267 // the type of the class being compared.
9268 auto PT = FD->getParamDecl(i: 0)->getType();
9269 CXXRecordDecl *RD = PT.getNonReferenceType()->getAsCXXRecordDecl();
9270 SourceLocation BodyLoc =
9271 FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
9272 StmtResult Body =
9273 DefaultedComparisonSynthesizer(*this, RD, FD, DCK, BodyLoc).build();
9274 if (Body.isInvalid()) {
9275 FD->setInvalidDecl();
9276 return;
9277 }
9278 FD->setBody(Body.get());
9279 FD->markUsed(C&: Context);
9280 }
9281
9282 // The exception specification is needed because we are defining the
9283 // function. Note that this will reuse the body we just built.
9284 ResolveExceptionSpec(Loc: UseLoc, FPT: FD->getType()->castAs<FunctionProtoType>());
9285
9286 if (ASTMutationListener *L = getASTMutationListener())
9287 L->CompletedImplicitDefinition(D: FD);
9288}
9289
9290static Sema::ImplicitExceptionSpecification
9291ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc,
9292 FunctionDecl *FD,
9293 Sema::DefaultedComparisonKind DCK) {
9294 ComputingExceptionSpec CES(S, FD, Loc);
9295 Sema::ImplicitExceptionSpecification ExceptSpec(S);
9296
9297 if (FD->isInvalidDecl())
9298 return ExceptSpec;
9299
9300 // The common case is that we just defined the comparison function. In that
9301 // case, just look at whether the body can throw.
9302 if (FD->hasBody()) {
9303 ExceptSpec.CalledStmt(S: FD->getBody());
9304 } else {
9305 // Otherwise, build a body so we can check it. This should ideally only
9306 // happen when we're not actually marking the function referenced. (This is
9307 // only really important for efficiency: we don't want to build and throw
9308 // away bodies for comparison functions more than we strictly need to.)
9309
9310 // Pretend to synthesize the function body in an unevaluated context.
9311 // Note that we can't actually just go ahead and define the function here:
9312 // we are not permitted to mark its callees as referenced.
9313 Sema::SynthesizedFunctionScope Scope(S, FD);
9314 EnterExpressionEvaluationContext Context(
9315 S, Sema::ExpressionEvaluationContext::Unevaluated);
9316
9317 CXXRecordDecl *RD =
9318 cast<CXXRecordDecl>(Val: FD->getFriendObjectKind() == Decl::FOK_None
9319 ? FD->getDeclContext()
9320 : FD->getLexicalDeclContext());
9321 SourceLocation BodyLoc =
9322 FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
9323 StmtResult Body =
9324 DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
9325 if (!Body.isInvalid())
9326 ExceptSpec.CalledStmt(S: Body.get());
9327
9328 // FIXME: Can we hold onto this body and just transform it to potentially
9329 // evaluated when we're asked to define the function rather than rebuilding
9330 // it? Either that, or we should only build the bits of the body that we
9331 // need (the expressions, not the statements).
9332 }
9333
9334 return ExceptSpec;
9335}
9336
9337void Sema::CheckDelayedMemberExceptionSpecs() {
9338 decltype(DelayedOverridingExceptionSpecChecks) Overriding;
9339 decltype(DelayedEquivalentExceptionSpecChecks) Equivalent;
9340
9341 std::swap(LHS&: Overriding, RHS&: DelayedOverridingExceptionSpecChecks);
9342 std::swap(LHS&: Equivalent, RHS&: DelayedEquivalentExceptionSpecChecks);
9343
9344 // Perform any deferred checking of exception specifications for virtual
9345 // destructors.
9346 for (auto &Check : Overriding)
9347 CheckOverridingFunctionExceptionSpec(New: Check.first, Old: Check.second);
9348
9349 // Perform any deferred checking of exception specifications for befriended
9350 // special members.
9351 for (auto &Check : Equivalent)
9352 CheckEquivalentExceptionSpec(Old: Check.second, New: Check.first);
9353}
9354
9355namespace {
9356/// CRTP base class for visiting operations performed by a special member
9357/// function (or inherited constructor).
9358template<typename Derived>
9359struct SpecialMemberVisitor {
9360 Sema &S;
9361 CXXMethodDecl *MD;
9362 CXXSpecialMemberKind CSM;
9363 Sema::InheritedConstructorInfo *ICI;
9364
9365 // Properties of the special member, computed for convenience.
9366 bool IsConstructor = false, IsAssignment = false, ConstArg = false;
9367
9368 SpecialMemberVisitor(Sema &S, CXXMethodDecl *MD, CXXSpecialMemberKind CSM,
9369 Sema::InheritedConstructorInfo *ICI)
9370 : S(S), MD(MD), CSM(CSM), ICI(ICI) {
9371 switch (CSM) {
9372 case CXXSpecialMemberKind::DefaultConstructor:
9373 case CXXSpecialMemberKind::CopyConstructor:
9374 case CXXSpecialMemberKind::MoveConstructor:
9375 IsConstructor = true;
9376 break;
9377 case CXXSpecialMemberKind::CopyAssignment:
9378 case CXXSpecialMemberKind::MoveAssignment:
9379 IsAssignment = true;
9380 break;
9381 case CXXSpecialMemberKind::Destructor:
9382 break;
9383 case CXXSpecialMemberKind::Invalid:
9384 llvm_unreachable("invalid special member kind");
9385 }
9386
9387 if (MD->getNumExplicitParams()) {
9388 if (const ReferenceType *RT =
9389 MD->getNonObjectParameter(I: 0)->getType()->getAs<ReferenceType>())
9390 ConstArg = RT->getPointeeType().isConstQualified();
9391 }
9392 }
9393
9394 Derived &getDerived() { return static_cast<Derived&>(*this); }
9395
9396 /// Is this a "move" special member?
9397 bool isMove() const {
9398 return CSM == CXXSpecialMemberKind::MoveConstructor ||
9399 CSM == CXXSpecialMemberKind::MoveAssignment;
9400 }
9401
9402 /// Look up the corresponding special member in the given class.
9403 Sema::SpecialMemberOverloadResult lookupIn(CXXRecordDecl *Class,
9404 unsigned Quals, bool IsMutable) {
9405 return lookupCallFromSpecialMember(S, Class, CSM, FieldQuals: Quals,
9406 ConstRHS: ConstArg && !IsMutable);
9407 }
9408
9409 /// Look up the constructor for the specified base class to see if it's
9410 /// overridden due to this being an inherited constructor.
9411 Sema::SpecialMemberOverloadResult lookupInheritedCtor(CXXRecordDecl *Class) {
9412 if (!ICI)
9413 return {};
9414 assert(CSM == CXXSpecialMemberKind::DefaultConstructor);
9415 auto *BaseCtor =
9416 cast<CXXConstructorDecl>(Val: MD)->getInheritedConstructor().getConstructor();
9417 if (auto *MD = ICI->findConstructorForBase(Base: Class, Ctor: BaseCtor).first)
9418 return MD;
9419 return {};
9420 }
9421
9422 /// A base or member subobject.
9423 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
9424
9425 /// Get the location to use for a subobject in diagnostics.
9426 static SourceLocation getSubobjectLoc(Subobject Subobj) {
9427 // FIXME: For an indirect virtual base, the direct base leading to
9428 // the indirect virtual base would be a more useful choice.
9429 if (auto *B = dyn_cast<CXXBaseSpecifier *>(Val&: Subobj))
9430 return B->getBaseTypeLoc();
9431 else
9432 return cast<FieldDecl *>(Val&: Subobj)->getLocation();
9433 }
9434
9435 enum BasesToVisit {
9436 /// Visit all non-virtual (direct) bases.
9437 VisitNonVirtualBases,
9438 /// Visit all direct bases, virtual or not.
9439 VisitDirectBases,
9440 /// Visit all non-virtual bases, and all virtual bases if the class
9441 /// is not abstract.
9442 VisitPotentiallyConstructedBases,
9443 /// Visit all direct or virtual bases.
9444 VisitAllBases
9445 };
9446
9447 // Visit the bases and members of the class.
9448 bool visit(BasesToVisit Bases) {
9449 CXXRecordDecl *RD = MD->getParent();
9450
9451 if (Bases == VisitPotentiallyConstructedBases)
9452 Bases = RD->isAbstract() ? VisitNonVirtualBases : VisitAllBases;
9453
9454 for (auto &B : RD->bases())
9455 if ((Bases == VisitDirectBases || !B.isVirtual()) &&
9456 getDerived().visitBase(&B))
9457 return true;
9458
9459 if (Bases == VisitAllBases)
9460 for (auto &B : RD->vbases())
9461 if (getDerived().visitBase(&B))
9462 return true;
9463
9464 for (auto *F : RD->fields())
9465 if (!F->isInvalidDecl() && !F->isUnnamedBitField() &&
9466 getDerived().visitField(F))
9467 return true;
9468
9469 return false;
9470 }
9471};
9472}
9473
9474namespace {
9475struct SpecialMemberDeletionInfo
9476 : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
9477 bool Diagnose;
9478
9479 SourceLocation Loc;
9480
9481 bool AllFieldsAreConst;
9482
9483 SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
9484 CXXSpecialMemberKind CSM,
9485 Sema::InheritedConstructorInfo *ICI, bool Diagnose)
9486 : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
9487 Loc(MD->getLocation()), AllFieldsAreConst(true) {}
9488
9489 bool inUnion() const { return MD->getParent()->isUnion(); }
9490
9491 CXXSpecialMemberKind getEffectiveCSM() {
9492 return ICI ? CXXSpecialMemberKind::Invalid : CSM;
9493 }
9494
9495 bool shouldDeleteForVariantObjCPtrMember(FieldDecl *FD, QualType FieldType);
9496
9497 bool shouldDeleteForVariantPtrAuthMember(const FieldDecl *FD);
9498
9499 bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
9500 bool visitField(FieldDecl *Field) { return shouldDeleteForField(FD: Field); }
9501
9502 bool shouldDeleteForBase(CXXBaseSpecifier *Base);
9503 bool shouldDeleteForField(FieldDecl *FD);
9504 bool shouldDeleteForAllConstMembers();
9505
9506 bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
9507 unsigned Quals);
9508 bool shouldDeleteForSubobjectCall(Subobject Subobj,
9509 Sema::SpecialMemberOverloadResult SMOR,
9510 bool IsDtorCallInCtor);
9511
9512 bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
9513};
9514}
9515
9516/// Is the given special member inaccessible when used on the given
9517/// sub-object.
9518bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
9519 CXXMethodDecl *target) {
9520 /// If we're operating on a base class, the object type is the
9521 /// type of this special member.
9522 CanQualType objectTy;
9523 AccessSpecifier access = target->getAccess();
9524 if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
9525 objectTy = S.Context.getCanonicalTagType(TD: MD->getParent());
9526 access = CXXRecordDecl::MergeAccess(PathAccess: base->getAccessSpecifier(), DeclAccess: access);
9527
9528 // If we're operating on a field, the object type is the type of the field.
9529 } else {
9530 objectTy = S.Context.getCanonicalTagType(TD: target->getParent());
9531 }
9532
9533 return S.isMemberAccessibleForDeletion(
9534 NamingClass: target->getParent(), Found: DeclAccessPair::make(D: target, AS: access), ObjectType: objectTy);
9535}
9536
9537/// Check whether we should delete a special member due to the implicit
9538/// definition containing a call to a special member of a subobject.
9539bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
9540 Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR,
9541 bool IsDtorCallInCtor) {
9542 CXXMethodDecl *Decl = SMOR.getMethod();
9543 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
9544
9545 enum {
9546 NotSet = -1,
9547 NoDecl,
9548 DeletedDecl,
9549 MultipleDecl,
9550 InaccessibleDecl,
9551 NonTrivialDecl
9552 } DiagKind = NotSet;
9553
9554 if (SMOR.getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted) {
9555 if (CSM == CXXSpecialMemberKind::DefaultConstructor && Field &&
9556 Field->getParent()->isUnion()) {
9557 // [class.default.ctor]p2:
9558 // A defaulted default constructor for class X is defined as deleted if
9559 // - X is a union that has a variant member with a non-trivial default
9560 // constructor and no variant member of X has a default member
9561 // initializer
9562 const auto *RD = cast<CXXRecordDecl>(Val: Field->getParent());
9563 if (RD->hasInClassInitializer())
9564 return false;
9565 }
9566 DiagKind = !Decl ? NoDecl : DeletedDecl;
9567 } else if (SMOR.getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
9568 DiagKind = MultipleDecl;
9569 else if (!isAccessible(Subobj, target: Decl))
9570 DiagKind = InaccessibleDecl;
9571 else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
9572 !Decl->isTrivial()) {
9573 // A member of a union must have a trivial corresponding special member.
9574 // As a weird special case, a destructor call from a union's constructor
9575 // must be accessible and non-deleted, but need not be trivial. Such a
9576 // destructor is never actually called, but is semantically checked as
9577 // if it were.
9578 if (CSM == CXXSpecialMemberKind::DefaultConstructor) {
9579 // [class.default.ctor]p2:
9580 // A defaulted default constructor for class X is defined as deleted if
9581 // - X is a union that has a variant member with a non-trivial default
9582 // constructor and no variant member of X has a default member
9583 // initializer
9584 const auto *RD = cast<CXXRecordDecl>(Val: Field->getParent());
9585 if (!RD->hasInClassInitializer())
9586 DiagKind = NonTrivialDecl;
9587 } else {
9588 DiagKind = NonTrivialDecl;
9589 }
9590 }
9591
9592 if (DiagKind == NotSet)
9593 return false;
9594
9595 if (Diagnose) {
9596 if (Field) {
9597 S.Diag(Loc: Field->getLocation(),
9598 DiagID: diag::note_deleted_special_member_class_subobject)
9599 << getEffectiveCSM() << MD->getParent() << /*IsField*/ true << Field
9600 << DiagKind << IsDtorCallInCtor << /*IsObjCPtr*/ false;
9601 } else {
9602 CXXBaseSpecifier *Base = cast<CXXBaseSpecifier *>(Val&: Subobj);
9603 S.Diag(Loc: Base->getBeginLoc(),
9604 DiagID: diag::note_deleted_special_member_class_subobject)
9605 << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
9606 << Base->getType() << DiagKind << IsDtorCallInCtor
9607 << /*IsObjCPtr*/ false;
9608 }
9609
9610 if (DiagKind == DeletedDecl)
9611 S.NoteDeletedFunction(FD: Decl);
9612 // FIXME: Explain inaccessibility if DiagKind == InaccessibleDecl.
9613 }
9614
9615 return true;
9616}
9617
9618/// Check whether we should delete a special member function due to having a
9619/// direct or virtual base class or non-static data member of class type M.
9620bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
9621 CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
9622 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
9623 bool IsMutable = Field && Field->isMutable();
9624
9625 // C++11 [class.ctor]p5:
9626 // -- any direct or virtual base class, or non-static data member with no
9627 // brace-or-equal-initializer, has class type M (or array thereof) and
9628 // either M has no default constructor or overload resolution as applied
9629 // to M's default constructor results in an ambiguity or in a function
9630 // that is deleted or inaccessible
9631 // C++11 [class.copy]p11, C++11 [class.copy]p23:
9632 // -- a direct or virtual base class B that cannot be copied/moved because
9633 // overload resolution, as applied to B's corresponding special member,
9634 // results in an ambiguity or a function that is deleted or inaccessible
9635 // from the defaulted special member
9636 // C++11 [class.dtor]p5:
9637 // -- any direct or virtual base class [...] has a type with a destructor
9638 // that is deleted or inaccessible
9639 if (!(CSM == CXXSpecialMemberKind::DefaultConstructor && Field &&
9640 Field->hasInClassInitializer()) &&
9641 shouldDeleteForSubobjectCall(Subobj, SMOR: lookupIn(Class, Quals, IsMutable),
9642 IsDtorCallInCtor: false))
9643 return true;
9644
9645 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
9646 // -- any direct or virtual base class or non-static data member has a
9647 // type with a destructor that is deleted or inaccessible
9648 if (IsConstructor) {
9649 Sema::SpecialMemberOverloadResult SMOR =
9650 S.LookupSpecialMember(D: Class, SM: CXXSpecialMemberKind::Destructor, ConstArg: false,
9651 VolatileArg: false, RValueThis: false, ConstThis: false, VolatileThis: false);
9652 if (shouldDeleteForSubobjectCall(Subobj, SMOR, IsDtorCallInCtor: true))
9653 return true;
9654 }
9655
9656 return false;
9657}
9658
9659bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
9660 FieldDecl *FD, QualType FieldType) {
9661 // The defaulted special functions are defined as deleted if this is a variant
9662 // member with a non-trivial ownership type, e.g., ObjC __strong or __weak
9663 // type under ARC.
9664 if (!FieldType.hasNonTrivialObjCLifetime())
9665 return false;
9666
9667 // Don't make the defaulted default constructor defined as deleted if the
9668 // member has an in-class initializer.
9669 if (CSM == CXXSpecialMemberKind::DefaultConstructor &&
9670 FD->hasInClassInitializer())
9671 return false;
9672
9673 if (Diagnose) {
9674 auto *ParentClass = cast<CXXRecordDecl>(Val: FD->getParent());
9675 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_deleted_special_member_class_subobject)
9676 << getEffectiveCSM() << ParentClass << /*IsField*/ true << FD << 4
9677 << /*IsDtorCallInCtor*/ false << /*IsObjCPtr*/ true;
9678 }
9679
9680 return true;
9681}
9682
9683bool SpecialMemberDeletionInfo::shouldDeleteForVariantPtrAuthMember(
9684 const FieldDecl *FD) {
9685 QualType FieldType = S.Context.getBaseElementType(QT: FD->getType());
9686 // Copy/move constructors/assignment operators are deleted if the field has an
9687 // address-discriminated ptrauth qualifier.
9688 PointerAuthQualifier Q = FieldType.getPointerAuth();
9689
9690 if (!Q || !Q.isAddressDiscriminated())
9691 return false;
9692
9693 if (CSM == CXXSpecialMemberKind::DefaultConstructor ||
9694 CSM == CXXSpecialMemberKind::Destructor)
9695 return false;
9696
9697 if (Diagnose) {
9698 auto *ParentClass = cast<CXXRecordDecl>(Val: FD->getParent());
9699 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_deleted_special_member_class_subobject)
9700 << getEffectiveCSM() << ParentClass << /*IsField*/ true << FD << 4
9701 << /*IsDtorCallInCtor*/ false << 2;
9702 }
9703
9704 return true;
9705}
9706
9707/// Check whether we should delete a special member function due to the class
9708/// having a particular direct or virtual base class.
9709bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
9710 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
9711 // If program is correct, BaseClass cannot be null, but if it is, the error
9712 // must be reported elsewhere.
9713 if (!BaseClass)
9714 return false;
9715 // If we have an inheriting constructor, check whether we're calling an
9716 // inherited constructor instead of a default constructor.
9717 Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(Class: BaseClass);
9718 if (auto *BaseCtor = SMOR.getMethod()) {
9719 // Note that we do not check access along this path; other than that,
9720 // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
9721 // FIXME: Check that the base has a usable destructor! Sink this into
9722 // shouldDeleteForClassSubobject.
9723 if (BaseCtor->isDeleted() && Diagnose) {
9724 S.Diag(Loc: Base->getBeginLoc(),
9725 DiagID: diag::note_deleted_special_member_class_subobject)
9726 << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
9727 << Base->getType() << /*Deleted*/ 1 << /*IsDtorCallInCtor*/ false
9728 << /*IsObjCPtr*/ false;
9729 S.NoteDeletedFunction(FD: BaseCtor);
9730 }
9731 return BaseCtor->isDeleted();
9732 }
9733 return shouldDeleteForClassSubobject(Class: BaseClass, Subobj: Base, Quals: 0);
9734}
9735
9736/// Check whether we should delete a special member function due to the class
9737/// having a particular non-static data member.
9738bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
9739 QualType FieldType = S.Context.getBaseElementType(QT: FD->getType());
9740 CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
9741
9742 if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
9743 return true;
9744
9745 if (inUnion() && shouldDeleteForVariantPtrAuthMember(FD))
9746 return true;
9747
9748 if (CSM == CXXSpecialMemberKind::DefaultConstructor) {
9749 // For a default constructor, all references must be initialized in-class
9750 // and, if a union, it must have a non-const member.
9751 if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
9752 if (Diagnose)
9753 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_deleted_default_ctor_uninit_field)
9754 << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
9755 return true;
9756 }
9757 // C++11 [class.ctor]p5 (modified by DR2394): any non-variant non-static
9758 // data member of const-qualified type (or array thereof) with no
9759 // brace-or-equal-initializer is not const-default-constructible.
9760 if (!inUnion() && FieldType.isConstQualified() &&
9761 !FD->hasInClassInitializer() &&
9762 (!FieldRecord || !FieldRecord->allowConstDefaultInit())) {
9763 if (Diagnose)
9764 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_deleted_default_ctor_uninit_field)
9765 << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
9766 return true;
9767 }
9768
9769 if (inUnion() && !FieldType.isConstQualified())
9770 AllFieldsAreConst = false;
9771 } else if (CSM == CXXSpecialMemberKind::CopyConstructor) {
9772 // For a copy constructor, data members must not be of rvalue reference
9773 // type.
9774 if (FieldType->isRValueReferenceType()) {
9775 if (Diagnose)
9776 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_deleted_copy_ctor_rvalue_reference)
9777 << MD->getParent() << FD << FieldType;
9778 return true;
9779 }
9780 } else if (IsAssignment) {
9781 // For an assignment operator, data members must not be of reference type.
9782 if (FieldType->isReferenceType()) {
9783 if (Diagnose)
9784 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_deleted_assign_field)
9785 << isMove() << MD->getParent() << FD << FieldType << /*Reference*/0;
9786 return true;
9787 }
9788 if (!FieldRecord && FieldType.isConstQualified()) {
9789 // C++11 [class.copy]p23:
9790 // -- a non-static data member of const non-class type (or array thereof)
9791 if (Diagnose)
9792 S.Diag(Loc: FD->getLocation(), DiagID: diag::note_deleted_assign_field)
9793 << isMove() << MD->getParent() << FD << FD->getType() << /*Const*/1;
9794 return true;
9795 }
9796 }
9797
9798 if (FieldRecord) {
9799 // Some additional restrictions exist on the variant members.
9800 if (!inUnion() && FieldRecord->isUnion() &&
9801 FieldRecord->isAnonymousStructOrUnion()) {
9802 bool AllVariantFieldsAreConst = true;
9803
9804 // FIXME: Handle anonymous unions declared within anonymous unions.
9805 for (auto *UI : FieldRecord->fields()) {
9806 QualType UnionFieldType = S.Context.getBaseElementType(QT: UI->getType());
9807
9808 if (shouldDeleteForVariantObjCPtrMember(FD: &*UI, FieldType: UnionFieldType))
9809 return true;
9810
9811 if (shouldDeleteForVariantPtrAuthMember(FD: &*UI))
9812 return true;
9813
9814 if (!UnionFieldType.isConstQualified())
9815 AllVariantFieldsAreConst = false;
9816
9817 CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
9818 if (UnionFieldRecord &&
9819 shouldDeleteForClassSubobject(Class: UnionFieldRecord, Subobj: UI,
9820 Quals: UnionFieldType.getCVRQualifiers()))
9821 return true;
9822 }
9823
9824 // At least one member in each anonymous union must be non-const
9825 if (CSM == CXXSpecialMemberKind::DefaultConstructor &&
9826 AllVariantFieldsAreConst && !FieldRecord->field_empty()) {
9827 if (Diagnose)
9828 S.Diag(Loc: FieldRecord->getLocation(),
9829 DiagID: diag::note_deleted_default_ctor_all_const)
9830 << !!ICI << MD->getParent() << /*anonymous union*/1;
9831 return true;
9832 }
9833
9834 // Don't check the implicit member of the anonymous union type.
9835 // This is technically non-conformant but supported, and we have a
9836 // diagnostic for this elsewhere.
9837 return false;
9838 }
9839
9840 if (shouldDeleteForClassSubobject(Class: FieldRecord, Subobj: FD,
9841 Quals: FieldType.getCVRQualifiers()))
9842 return true;
9843 }
9844
9845 return false;
9846}
9847
9848/// C++11 [class.ctor] p5:
9849/// A defaulted default constructor for a class X is defined as deleted if
9850/// X is a union and all of its variant members are of const-qualified type.
9851bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
9852 // This is a silly definition, because it gives an empty union a deleted
9853 // default constructor. Don't do that.
9854 if (CSM == CXXSpecialMemberKind::DefaultConstructor && inUnion() &&
9855 AllFieldsAreConst) {
9856 bool AnyFields = false;
9857 for (auto *F : MD->getParent()->fields())
9858 if ((AnyFields = !F->isUnnamedBitField()))
9859 break;
9860 if (!AnyFields)
9861 return false;
9862 if (Diagnose)
9863 S.Diag(Loc: MD->getParent()->getLocation(),
9864 DiagID: diag::note_deleted_default_ctor_all_const)
9865 << !!ICI << MD->getParent() << /*not anonymous union*/0;
9866 return true;
9867 }
9868 return false;
9869}
9870
9871/// Determine whether a defaulted special member function should be defined as
9872/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
9873/// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
9874bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD,
9875 CXXSpecialMemberKind CSM,
9876 InheritedConstructorInfo *ICI,
9877 bool Diagnose) {
9878 if (MD->isInvalidDecl())
9879 return false;
9880 CXXRecordDecl *RD = MD->getParent();
9881 assert(!RD->isDependentType() && "do deletion after instantiation");
9882 if (!LangOpts.CPlusPlus || (!LangOpts.CPlusPlus11 && !RD->isLambda()) ||
9883 RD->isInvalidDecl())
9884 return false;
9885
9886 // C++11 [expr.lambda.prim]p19:
9887 // The closure type associated with a lambda-expression has a
9888 // deleted (8.4.3) default constructor and a deleted copy
9889 // assignment operator.
9890 // C++2a adds back these operators if the lambda has no lambda-capture.
9891 if (RD->isLambda() && !RD->lambdaIsDefaultConstructibleAndAssignable() &&
9892 (CSM == CXXSpecialMemberKind::DefaultConstructor ||
9893 CSM == CXXSpecialMemberKind::CopyAssignment)) {
9894 if (Diagnose)
9895 Diag(Loc: RD->getLocation(), DiagID: diag::note_lambda_decl);
9896 return true;
9897 }
9898
9899 // C++11 [class.copy]p7, p18:
9900 // If the class definition declares a move constructor or move assignment
9901 // operator, an implicitly declared copy constructor or copy assignment
9902 // operator is defined as deleted.
9903 if (MD->isImplicit() && (CSM == CXXSpecialMemberKind::CopyConstructor ||
9904 CSM == CXXSpecialMemberKind::CopyAssignment)) {
9905 CXXMethodDecl *UserDeclaredMove = nullptr;
9906
9907 // In Microsoft mode up to MSVC 2013, a user-declared move only causes the
9908 // deletion of the corresponding copy operation, not both copy operations.
9909 // MSVC 2015 has adopted the standards conforming behavior.
9910 bool DeletesOnlyMatchingCopy =
9911 getLangOpts().MSVCCompat &&
9912 !getLangOpts().isCompatibleWithMSVC(MajorVersion: LangOptions::MSVC2015);
9913
9914 if (RD->hasUserDeclaredMoveConstructor() &&
9915 (!DeletesOnlyMatchingCopy ||
9916 CSM == CXXSpecialMemberKind::CopyConstructor)) {
9917 if (!Diagnose) return true;
9918
9919 // Find any user-declared move constructor.
9920 for (auto *I : RD->ctors()) {
9921 if (I->isMoveConstructor()) {
9922 UserDeclaredMove = I;
9923 break;
9924 }
9925 }
9926 assert(UserDeclaredMove);
9927 } else if (RD->hasUserDeclaredMoveAssignment() &&
9928 (!DeletesOnlyMatchingCopy ||
9929 CSM == CXXSpecialMemberKind::CopyAssignment)) {
9930 if (!Diagnose) return true;
9931
9932 // Find any user-declared move assignment operator.
9933 for (auto *I : RD->methods()) {
9934 if (I->isMoveAssignmentOperator()) {
9935 UserDeclaredMove = I;
9936 break;
9937 }
9938 }
9939 assert(UserDeclaredMove);
9940 }
9941
9942 if (UserDeclaredMove) {
9943 Diag(Loc: UserDeclaredMove->getLocation(),
9944 DiagID: diag::note_deleted_copy_user_declared_move)
9945 << (CSM == CXXSpecialMemberKind::CopyAssignment) << RD
9946 << UserDeclaredMove->isMoveAssignmentOperator();
9947 return true;
9948 }
9949 }
9950
9951 // Do access control from the special member function
9952 ContextRAII MethodContext(*this, MD);
9953
9954 // C++11 [class.dtor]p5:
9955 // -- for a virtual destructor, lookup of the non-array deallocation function
9956 // results in an ambiguity or in a function that is deleted or inaccessible
9957 if (CSM == CXXSpecialMemberKind::Destructor && MD->isVirtual()) {
9958 FunctionDecl *OperatorDelete = nullptr;
9959 CanQualType DeallocType = Context.getCanonicalTagType(TD: RD);
9960 DeclarationName Name =
9961 Context.DeclarationNames.getCXXOperatorName(Op: OO_Delete);
9962 ImplicitDeallocationParameters IDP = {
9963 DeallocType, ShouldUseTypeAwareOperatorNewOrDelete(),
9964 AlignedAllocationMode::No, SizedDeallocationMode::No};
9965 if (FindDeallocationFunction(StartLoc: MD->getLocation(), RD: MD->getParent(), Name,
9966 Operator&: OperatorDelete, IDP,
9967 /*Diagnose=*/false)) {
9968 if (Diagnose)
9969 Diag(Loc: RD->getLocation(), DiagID: diag::note_deleted_dtor_no_operator_delete);
9970 return true;
9971 }
9972 }
9973
9974 SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
9975
9976 // Per DR1611, do not consider virtual bases of constructors of abstract
9977 // classes, since we are not going to construct them.
9978 // Per DR1658, do not consider virtual bases of destructors of abstract
9979 // classes either.
9980 // Per DR2180, for assignment operators we only assign (and thus only
9981 // consider) direct bases.
9982 if (SMI.visit(Bases: SMI.IsAssignment ? SMI.VisitDirectBases
9983 : SMI.VisitPotentiallyConstructedBases))
9984 return true;
9985
9986 if (SMI.shouldDeleteForAllConstMembers())
9987 return true;
9988
9989 if (getLangOpts().CUDA) {
9990 // We should delete the special member in CUDA mode if target inference
9991 // failed.
9992 // For inherited constructors (non-null ICI), CSM may be passed so that MD
9993 // is treated as certain special member, which may not reflect what special
9994 // member MD really is. However inferTargetForImplicitSpecialMember
9995 // expects CSM to match MD, therefore recalculate CSM.
9996 assert(ICI || CSM == getSpecialMember(MD));
9997 auto RealCSM = CSM;
9998 if (ICI)
9999 RealCSM = getSpecialMember(MD);
10000
10001 return CUDA().inferTargetForImplicitSpecialMember(ClassDecl: RD, CSM: RealCSM, MemberDecl: MD,
10002 ConstRHS: SMI.ConstArg, Diagnose);
10003 }
10004
10005 return false;
10006}
10007
10008void Sema::DiagnoseDeletedDefaultedFunction(FunctionDecl *FD) {
10009 DefaultedFunctionKind DFK = getDefaultedFunctionKind(FD);
10010 assert(DFK && "not a defaultable function");
10011 assert(FD->isDefaulted() && FD->isDeleted() && "not defaulted and deleted");
10012
10013 if (DFK.isSpecialMember()) {
10014 ShouldDeleteSpecialMember(MD: cast<CXXMethodDecl>(Val: FD), CSM: DFK.asSpecialMember(),
10015 ICI: nullptr, /*Diagnose=*/true);
10016 } else {
10017 DefaultedComparisonAnalyzer(
10018 *this, cast<CXXRecordDecl>(Val: FD->getLexicalDeclContext()), FD,
10019 DFK.asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
10020 .visit();
10021 }
10022}
10023
10024/// Perform lookup for a special member of the specified kind, and determine
10025/// whether it is trivial. If the triviality can be determined without the
10026/// lookup, skip it. This is intended for use when determining whether a
10027/// special member of a containing object is trivial, and thus does not ever
10028/// perform overload resolution for default constructors.
10029///
10030/// If \p Selected is not \c NULL, \c *Selected will be filled in with the
10031/// member that was most likely to be intended to be trivial, if any.
10032///
10033/// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
10034/// determine whether the special member is trivial.
10035static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD,
10036 CXXSpecialMemberKind CSM, unsigned Quals,
10037 bool ConstRHS, TrivialABIHandling TAH,
10038 CXXMethodDecl **Selected) {
10039 if (Selected)
10040 *Selected = nullptr;
10041
10042 switch (CSM) {
10043 case CXXSpecialMemberKind::Invalid:
10044 llvm_unreachable("not a special member");
10045
10046 case CXXSpecialMemberKind::DefaultConstructor:
10047 // C++11 [class.ctor]p5:
10048 // A default constructor is trivial if:
10049 // - all the [direct subobjects] have trivial default constructors
10050 //
10051 // Note, no overload resolution is performed in this case.
10052 if (RD->hasTrivialDefaultConstructor())
10053 return true;
10054
10055 if (Selected) {
10056 // If there's a default constructor which could have been trivial, dig it
10057 // out. Otherwise, if there's any user-provided default constructor, point
10058 // to that as an example of why there's not a trivial one.
10059 CXXConstructorDecl *DefCtor = nullptr;
10060 if (RD->needsImplicitDefaultConstructor())
10061 S.DeclareImplicitDefaultConstructor(ClassDecl: RD);
10062 for (auto *CI : RD->ctors()) {
10063 if (!CI->isDefaultConstructor())
10064 continue;
10065 DefCtor = CI;
10066 if (!DefCtor->isUserProvided())
10067 break;
10068 }
10069
10070 *Selected = DefCtor;
10071 }
10072
10073 return false;
10074
10075 case CXXSpecialMemberKind::Destructor:
10076 // C++11 [class.dtor]p5:
10077 // A destructor is trivial if:
10078 // - all the direct [subobjects] have trivial destructors
10079 if (RD->hasTrivialDestructor() ||
10080 (TAH == TrivialABIHandling::ConsiderTrivialABI &&
10081 RD->hasTrivialDestructorForCall()))
10082 return true;
10083
10084 if (Selected) {
10085 if (RD->needsImplicitDestructor())
10086 S.DeclareImplicitDestructor(ClassDecl: RD);
10087 *Selected = RD->getDestructor();
10088 }
10089
10090 return false;
10091
10092 case CXXSpecialMemberKind::CopyConstructor:
10093 // C++11 [class.copy]p12:
10094 // A copy constructor is trivial if:
10095 // - the constructor selected to copy each direct [subobject] is trivial
10096 if (RD->hasTrivialCopyConstructor() ||
10097 (TAH == TrivialABIHandling::ConsiderTrivialABI &&
10098 RD->hasTrivialCopyConstructorForCall())) {
10099 if (Quals == Qualifiers::Const)
10100 // We must either select the trivial copy constructor or reach an
10101 // ambiguity; no need to actually perform overload resolution.
10102 return true;
10103 } else if (!Selected) {
10104 return false;
10105 }
10106 // In C++98, we are not supposed to perform overload resolution here, but we
10107 // treat that as a language defect, as suggested on cxx-abi-dev, to treat
10108 // cases like B as having a non-trivial copy constructor:
10109 // struct A { template<typename T> A(T&); };
10110 // struct B { mutable A a; };
10111 goto NeedOverloadResolution;
10112
10113 case CXXSpecialMemberKind::CopyAssignment:
10114 // C++11 [class.copy]p25:
10115 // A copy assignment operator is trivial if:
10116 // - the assignment operator selected to copy each direct [subobject] is
10117 // trivial
10118 if (RD->hasTrivialCopyAssignment()) {
10119 if (Quals == Qualifiers::Const)
10120 return true;
10121 } else if (!Selected) {
10122 return false;
10123 }
10124 // In C++98, we are not supposed to perform overload resolution here, but we
10125 // treat that as a language defect.
10126 goto NeedOverloadResolution;
10127
10128 case CXXSpecialMemberKind::MoveConstructor:
10129 case CXXSpecialMemberKind::MoveAssignment:
10130 NeedOverloadResolution:
10131 Sema::SpecialMemberOverloadResult SMOR =
10132 lookupCallFromSpecialMember(S, Class: RD, CSM, FieldQuals: Quals, ConstRHS);
10133
10134 // The standard doesn't describe how to behave if the lookup is ambiguous.
10135 // We treat it as not making the member non-trivial, just like the standard
10136 // mandates for the default constructor. This should rarely matter, because
10137 // the member will also be deleted.
10138 if (SMOR.getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
10139 return true;
10140
10141 if (!SMOR.getMethod()) {
10142 assert(SMOR.getKind() ==
10143 Sema::SpecialMemberOverloadResult::NoMemberOrDeleted);
10144 return false;
10145 }
10146
10147 // We deliberately don't check if we found a deleted special member. We're
10148 // not supposed to!
10149 if (Selected)
10150 *Selected = SMOR.getMethod();
10151
10152 if (TAH == TrivialABIHandling::ConsiderTrivialABI &&
10153 (CSM == CXXSpecialMemberKind::CopyConstructor ||
10154 CSM == CXXSpecialMemberKind::MoveConstructor))
10155 return SMOR.getMethod()->isTrivialForCall();
10156 return SMOR.getMethod()->isTrivial();
10157 }
10158
10159 llvm_unreachable("unknown special method kind");
10160}
10161
10162static CXXConstructorDecl *findUserDeclaredCtor(CXXRecordDecl *RD) {
10163 for (auto *CI : RD->ctors())
10164 if (!CI->isImplicit())
10165 return CI;
10166
10167 // Look for constructor templates.
10168 typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
10169 for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
10170 if (CXXConstructorDecl *CD =
10171 dyn_cast<CXXConstructorDecl>(Val: TI->getTemplatedDecl()))
10172 return CD;
10173 }
10174
10175 return nullptr;
10176}
10177
10178/// The kind of subobject we are checking for triviality. The values of this
10179/// enumeration are used in diagnostics.
10180enum TrivialSubobjectKind {
10181 /// The subobject is a base class.
10182 TSK_BaseClass,
10183 /// The subobject is a non-static data member.
10184 TSK_Field,
10185 /// The object is actually the complete object.
10186 TSK_CompleteObject
10187};
10188
10189/// Check whether the special member selected for a given type would be trivial.
10190static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc,
10191 QualType SubType, bool ConstRHS,
10192 CXXSpecialMemberKind CSM,
10193 TrivialSubobjectKind Kind,
10194 TrivialABIHandling TAH, bool Diagnose) {
10195 CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
10196 if (!SubRD)
10197 return true;
10198
10199 CXXMethodDecl *Selected;
10200 if (findTrivialSpecialMember(S, RD: SubRD, CSM, Quals: SubType.getCVRQualifiers(),
10201 ConstRHS, TAH, Selected: Diagnose ? &Selected : nullptr))
10202 return true;
10203
10204 if (Diagnose) {
10205 if (ConstRHS)
10206 SubType.addConst();
10207
10208 if (!Selected && CSM == CXXSpecialMemberKind::DefaultConstructor) {
10209 S.Diag(Loc: SubobjLoc, DiagID: diag::note_nontrivial_no_def_ctor)
10210 << Kind << SubType.getUnqualifiedType();
10211 if (CXXConstructorDecl *CD = findUserDeclaredCtor(RD: SubRD))
10212 S.Diag(Loc: CD->getLocation(), DiagID: diag::note_user_declared_ctor);
10213 } else if (!Selected)
10214 S.Diag(Loc: SubobjLoc, DiagID: diag::note_nontrivial_no_copy)
10215 << Kind << SubType.getUnqualifiedType() << CSM << SubType;
10216 else if (Selected->isUserProvided()) {
10217 if (Kind == TSK_CompleteObject)
10218 S.Diag(Loc: Selected->getLocation(), DiagID: diag::note_nontrivial_user_provided)
10219 << Kind << SubType.getUnqualifiedType() << CSM;
10220 else {
10221 S.Diag(Loc: SubobjLoc, DiagID: diag::note_nontrivial_user_provided)
10222 << Kind << SubType.getUnqualifiedType() << CSM;
10223 S.Diag(Loc: Selected->getLocation(), DiagID: diag::note_declared_at);
10224 }
10225 } else {
10226 if (Kind != TSK_CompleteObject)
10227 S.Diag(Loc: SubobjLoc, DiagID: diag::note_nontrivial_subobject)
10228 << Kind << SubType.getUnqualifiedType() << CSM;
10229
10230 // Explain why the defaulted or deleted special member isn't trivial.
10231 S.SpecialMemberIsTrivial(MD: Selected, CSM,
10232 TAH: TrivialABIHandling::IgnoreTrivialABI, Diagnose);
10233 }
10234 }
10235
10236 return false;
10237}
10238
10239/// Check whether the members of a class type allow a special member to be
10240/// trivial.
10241static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD,
10242 CXXSpecialMemberKind CSM, bool ConstArg,
10243 TrivialABIHandling TAH, bool Diagnose) {
10244 for (const auto *FI : RD->fields()) {
10245 if (FI->isInvalidDecl() || FI->isUnnamedBitField())
10246 continue;
10247
10248 QualType FieldType = S.Context.getBaseElementType(QT: FI->getType());
10249
10250 // Pretend anonymous struct or union members are members of this class.
10251 if (FI->isAnonymousStructOrUnion()) {
10252 if (!checkTrivialClassMembers(S, RD: FieldType->getAsCXXRecordDecl(),
10253 CSM, ConstArg, TAH, Diagnose))
10254 return false;
10255 continue;
10256 }
10257
10258 // C++11 [class.ctor]p5:
10259 // A default constructor is trivial if [...]
10260 // -- no non-static data member of its class has a
10261 // brace-or-equal-initializer
10262 if (CSM == CXXSpecialMemberKind::DefaultConstructor &&
10263 FI->hasInClassInitializer()) {
10264 if (Diagnose)
10265 S.Diag(Loc: FI->getLocation(), DiagID: diag::note_nontrivial_default_member_init)
10266 << FI;
10267 return false;
10268 }
10269
10270 // Objective C ARC 4.3.5:
10271 // [...] nontrivally ownership-qualified types are [...] not trivially
10272 // default constructible, copy constructible, move constructible, copy
10273 // assignable, move assignable, or destructible [...]
10274 if (FieldType.hasNonTrivialObjCLifetime()) {
10275 if (Diagnose)
10276 S.Diag(Loc: FI->getLocation(), DiagID: diag::note_nontrivial_objc_ownership)
10277 << RD << FieldType.getObjCLifetime();
10278 return false;
10279 }
10280
10281 bool ConstRHS = ConstArg && !FI->isMutable();
10282 if (!checkTrivialSubobjectCall(S, SubobjLoc: FI->getLocation(), SubType: FieldType, ConstRHS,
10283 CSM, Kind: TSK_Field, TAH, Diagnose))
10284 return false;
10285 }
10286
10287 return true;
10288}
10289
10290void Sema::DiagnoseNontrivial(const CXXRecordDecl *RD,
10291 CXXSpecialMemberKind CSM) {
10292 CanQualType Ty = Context.getCanonicalTagType(TD: RD);
10293
10294 bool ConstArg = (CSM == CXXSpecialMemberKind::CopyConstructor ||
10295 CSM == CXXSpecialMemberKind::CopyAssignment);
10296 checkTrivialSubobjectCall(S&: *this, SubobjLoc: RD->getLocation(), SubType: Ty, ConstRHS: ConstArg, CSM,
10297 Kind: TSK_CompleteObject,
10298 TAH: TrivialABIHandling::IgnoreTrivialABI,
10299 /*Diagnose*/ true);
10300}
10301
10302bool Sema::SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM,
10303 TrivialABIHandling TAH, bool Diagnose) {
10304 assert(!MD->isUserProvided() && CSM != CXXSpecialMemberKind::Invalid &&
10305 "not special enough");
10306
10307 CXXRecordDecl *RD = MD->getParent();
10308
10309 bool ConstArg = false;
10310
10311 // C++11 [class.copy]p12, p25: [DR1593]
10312 // A [special member] is trivial if [...] its parameter-type-list is
10313 // equivalent to the parameter-type-list of an implicit declaration [...]
10314 switch (CSM) {
10315 case CXXSpecialMemberKind::DefaultConstructor:
10316 case CXXSpecialMemberKind::Destructor:
10317 // Trivial default constructors and destructors cannot have parameters.
10318 break;
10319
10320 case CXXSpecialMemberKind::CopyConstructor:
10321 case CXXSpecialMemberKind::CopyAssignment: {
10322 const ParmVarDecl *Param0 = MD->getNonObjectParameter(I: 0);
10323 const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
10324
10325 // When ClangABICompat14 is true, CXX copy constructors will only be trivial
10326 // if they are not user-provided and their parameter-type-list is equivalent
10327 // to the parameter-type-list of an implicit declaration. This maintains the
10328 // behavior before dr2171 was implemented.
10329 //
10330 // Otherwise, if ClangABICompat14 is false, All copy constructors can be
10331 // trivial, if they are not user-provided, regardless of the qualifiers on
10332 // the reference type.
10333 const bool ClangABICompat14 = Context.getLangOpts().getClangABICompat() <=
10334 LangOptions::ClangABI::Ver14;
10335 if (!RT ||
10336 ((RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) &&
10337 ClangABICompat14)) {
10338 if (Diagnose)
10339 Diag(Loc: Param0->getLocation(), DiagID: diag::note_nontrivial_param_type)
10340 << Param0->getSourceRange() << Param0->getType()
10341 << Context.getLValueReferenceType(
10342 T: Context.getCanonicalTagType(TD: RD).withConst());
10343 return false;
10344 }
10345
10346 ConstArg = RT->getPointeeType().isConstQualified();
10347 break;
10348 }
10349
10350 case CXXSpecialMemberKind::MoveConstructor:
10351 case CXXSpecialMemberKind::MoveAssignment: {
10352 // Trivial move operations always have non-cv-qualified parameters.
10353 const ParmVarDecl *Param0 = MD->getNonObjectParameter(I: 0);
10354 const RValueReferenceType *RT =
10355 Param0->getType()->getAs<RValueReferenceType>();
10356 if (!RT || RT->getPointeeType().getCVRQualifiers()) {
10357 if (Diagnose)
10358 Diag(Loc: Param0->getLocation(), DiagID: diag::note_nontrivial_param_type)
10359 << Param0->getSourceRange() << Param0->getType()
10360 << Context.getRValueReferenceType(T: Context.getCanonicalTagType(TD: RD));
10361 return false;
10362 }
10363 break;
10364 }
10365
10366 case CXXSpecialMemberKind::Invalid:
10367 llvm_unreachable("not a special member");
10368 }
10369
10370 if (MD->getMinRequiredArguments() < MD->getNumParams()) {
10371 if (Diagnose)
10372 Diag(Loc: MD->getParamDecl(i: MD->getMinRequiredArguments())->getLocation(),
10373 DiagID: diag::note_nontrivial_default_arg)
10374 << MD->getParamDecl(i: MD->getMinRequiredArguments())->getSourceRange();
10375 return false;
10376 }
10377 if (MD->isVariadic()) {
10378 if (Diagnose)
10379 Diag(Loc: MD->getLocation(), DiagID: diag::note_nontrivial_variadic);
10380 return false;
10381 }
10382
10383 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
10384 // A copy/move [constructor or assignment operator] is trivial if
10385 // -- the [member] selected to copy/move each direct base class subobject
10386 // is trivial
10387 //
10388 // C++11 [class.copy]p12, C++11 [class.copy]p25:
10389 // A [default constructor or destructor] is trivial if
10390 // -- all the direct base classes have trivial [default constructors or
10391 // destructors]
10392 for (const auto &BI : RD->bases())
10393 if (!checkTrivialSubobjectCall(S&: *this, SubobjLoc: BI.getBeginLoc(), SubType: BI.getType(),
10394 ConstRHS: ConstArg, CSM, Kind: TSK_BaseClass, TAH, Diagnose))
10395 return false;
10396
10397 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
10398 // A copy/move [constructor or assignment operator] for a class X is
10399 // trivial if
10400 // -- for each non-static data member of X that is of class type (or array
10401 // thereof), the constructor selected to copy/move that member is
10402 // trivial
10403 //
10404 // C++11 [class.copy]p12, C++11 [class.copy]p25:
10405 // A [default constructor or destructor] is trivial if
10406 // -- for all of the non-static data members of its class that are of class
10407 // type (or array thereof), each such class has a trivial [default
10408 // constructor or destructor]
10409 if (!checkTrivialClassMembers(S&: *this, RD, CSM, ConstArg, TAH, Diagnose))
10410 return false;
10411
10412 // C++11 [class.dtor]p5:
10413 // A destructor is trivial if [...]
10414 // -- the destructor is not virtual
10415 if (CSM == CXXSpecialMemberKind::Destructor && MD->isVirtual()) {
10416 if (Diagnose)
10417 Diag(Loc: MD->getLocation(), DiagID: diag::note_nontrivial_virtual_dtor) << RD;
10418 return false;
10419 }
10420
10421 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
10422 // A [special member] for class X is trivial if [...]
10423 // -- class X has no virtual functions and no virtual base classes
10424 if (CSM != CXXSpecialMemberKind::Destructor &&
10425 MD->getParent()->isDynamicClass()) {
10426 if (!Diagnose)
10427 return false;
10428
10429 if (RD->getNumVBases()) {
10430 // Check for virtual bases. We already know that the corresponding
10431 // member in all bases is trivial, so vbases must all be direct.
10432 CXXBaseSpecifier &BS = *RD->vbases_begin();
10433 assert(BS.isVirtual());
10434 Diag(Loc: BS.getBeginLoc(), DiagID: diag::note_nontrivial_has_virtual) << RD << 1;
10435 return false;
10436 }
10437
10438 // Must have a virtual method.
10439 for (const auto *MI : RD->methods()) {
10440 if (MI->isVirtual()) {
10441 SourceLocation MLoc = MI->getBeginLoc();
10442 Diag(Loc: MLoc, DiagID: diag::note_nontrivial_has_virtual) << RD << 0;
10443 return false;
10444 }
10445 }
10446
10447 llvm_unreachable("dynamic class with no vbases and no virtual functions");
10448 }
10449
10450 // Looks like it's trivial!
10451 return true;
10452}
10453
10454namespace {
10455struct FindHiddenVirtualMethod {
10456 Sema *S;
10457 CXXMethodDecl *Method;
10458 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
10459 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
10460
10461private:
10462 /// Check whether any most overridden method from MD in Methods
10463 static bool CheckMostOverridenMethods(
10464 const CXXMethodDecl *MD,
10465 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
10466 if (MD->size_overridden_methods() == 0)
10467 return Methods.count(Ptr: MD->getCanonicalDecl());
10468 for (const CXXMethodDecl *O : MD->overridden_methods())
10469 if (CheckMostOverridenMethods(MD: O, Methods))
10470 return true;
10471 return false;
10472 }
10473
10474public:
10475 /// Member lookup function that determines whether a given C++
10476 /// method overloads virtual methods in a base class without overriding any,
10477 /// to be used with CXXRecordDecl::lookupInBases().
10478 bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
10479 auto *BaseRecord = Specifier->getType()->castAsRecordDecl();
10480 DeclarationName Name = Method->getDeclName();
10481 assert(Name.getNameKind() == DeclarationName::Identifier);
10482
10483 bool foundSameNameMethod = false;
10484 SmallVector<CXXMethodDecl *, 8> overloadedMethods;
10485 for (Path.Decls = BaseRecord->lookup(Name).begin();
10486 Path.Decls != DeclContext::lookup_iterator(); ++Path.Decls) {
10487 NamedDecl *D = *Path.Decls;
10488 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: D)) {
10489 MD = MD->getCanonicalDecl();
10490 foundSameNameMethod = true;
10491 // Interested only in hidden virtual methods.
10492 if (!MD->isVirtual())
10493 continue;
10494 // If the method we are checking overrides a method from its base
10495 // don't warn about the other overloaded methods. Clang deviates from
10496 // GCC by only diagnosing overloads of inherited virtual functions that
10497 // do not override any other virtual functions in the base. GCC's
10498 // -Woverloaded-virtual diagnoses any derived function hiding a virtual
10499 // function from a base class. These cases may be better served by a
10500 // warning (not specific to virtual functions) on call sites when the
10501 // call would select a different function from the base class, were it
10502 // visible.
10503 // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
10504 if (!S->IsOverload(New: Method, Old: MD, UseMemberUsingDeclRules: false))
10505 return true;
10506 // Collect the overload only if its hidden.
10507 if (!CheckMostOverridenMethods(MD, Methods: OverridenAndUsingBaseMethods))
10508 overloadedMethods.push_back(Elt: MD);
10509 }
10510 }
10511
10512 if (foundSameNameMethod)
10513 OverloadedMethods.append(in_start: overloadedMethods.begin(),
10514 in_end: overloadedMethods.end());
10515 return foundSameNameMethod;
10516 }
10517};
10518} // end anonymous namespace
10519
10520/// Add the most overridden methods from MD to Methods
10521static void AddMostOverridenMethods(const CXXMethodDecl *MD,
10522 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
10523 if (MD->size_overridden_methods() == 0)
10524 Methods.insert(Ptr: MD->getCanonicalDecl());
10525 else
10526 for (const CXXMethodDecl *O : MD->overridden_methods())
10527 AddMostOverridenMethods(MD: O, Methods);
10528}
10529
10530void Sema::FindHiddenVirtualMethods(CXXMethodDecl *MD,
10531 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
10532 if (!MD->getDeclName().isIdentifier())
10533 return;
10534
10535 CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
10536 /*bool RecordPaths=*/false,
10537 /*bool DetectVirtual=*/false);
10538 FindHiddenVirtualMethod FHVM;
10539 FHVM.Method = MD;
10540 FHVM.S = this;
10541
10542 // Keep the base methods that were overridden or introduced in the subclass
10543 // by 'using' in a set. A base method not in this set is hidden.
10544 CXXRecordDecl *DC = MD->getParent();
10545 for (NamedDecl *ND : DC->lookup(Name: MD->getDeclName())) {
10546 if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(Val: ND))
10547 ND = shad->getTargetDecl();
10548 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: ND))
10549 AddMostOverridenMethods(MD, Methods&: FHVM.OverridenAndUsingBaseMethods);
10550 }
10551
10552 if (DC->lookupInBases(BaseMatches: FHVM, Paths))
10553 OverloadedMethods = FHVM.OverloadedMethods;
10554}
10555
10556void Sema::NoteHiddenVirtualMethods(CXXMethodDecl *MD,
10557 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
10558 for (const CXXMethodDecl *overloadedMD : OverloadedMethods) {
10559 PartialDiagnostic PD = PDiag(
10560 DiagID: diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
10561 HandleFunctionTypeMismatch(PDiag&: PD, FromType: MD->getType(), ToType: overloadedMD->getType());
10562 Diag(Loc: overloadedMD->getLocation(), PD);
10563 }
10564}
10565
10566void Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) {
10567 if (MD->isInvalidDecl())
10568 return;
10569
10570 if (Diags.isIgnored(DiagID: diag::warn_overloaded_virtual, Loc: MD->getLocation()))
10571 return;
10572
10573 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
10574 FindHiddenVirtualMethods(MD, OverloadedMethods);
10575 if (!OverloadedMethods.empty()) {
10576 Diag(Loc: MD->getLocation(), DiagID: diag::warn_overloaded_virtual)
10577 << MD << (OverloadedMethods.size() > 1);
10578
10579 NoteHiddenVirtualMethods(MD, OverloadedMethods);
10580 }
10581}
10582
10583void Sema::checkIllFormedTrivialABIStruct(CXXRecordDecl &RD) {
10584 auto PrintDiagAndRemoveAttr = [&](unsigned N) {
10585 // No diagnostics if this is a template instantiation.
10586 if (!isTemplateInstantiation(Kind: RD.getTemplateSpecializationKind())) {
10587 Diag(Loc: RD.getAttr<TrivialABIAttr>()->getLocation(),
10588 DiagID: diag::ext_cannot_use_trivial_abi) << &RD;
10589 Diag(Loc: RD.getAttr<TrivialABIAttr>()->getLocation(),
10590 DiagID: diag::note_cannot_use_trivial_abi_reason) << &RD << N;
10591 }
10592 RD.dropAttr<TrivialABIAttr>();
10593 };
10594
10595 // Ill-formed if the struct has virtual functions.
10596 if (RD.isPolymorphic()) {
10597 PrintDiagAndRemoveAttr(1);
10598 return;
10599 }
10600
10601 for (const auto &B : RD.bases()) {
10602 // Ill-formed if the base class is non-trivial for the purpose of calls or a
10603 // virtual base.
10604 if (!B.getType()->isDependentType() &&
10605 !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) {
10606 PrintDiagAndRemoveAttr(2);
10607 return;
10608 }
10609
10610 if (B.isVirtual()) {
10611 PrintDiagAndRemoveAttr(3);
10612 return;
10613 }
10614 }
10615
10616 for (const auto *FD : RD.fields()) {
10617 // Ill-formed if the field is an ObjectiveC pointer or of a type that is
10618 // non-trivial for the purpose of calls.
10619 QualType FT = FD->getType();
10620 if (FT.getObjCLifetime() == Qualifiers::OCL_Weak) {
10621 PrintDiagAndRemoveAttr(4);
10622 return;
10623 }
10624
10625 // Ill-formed if the field is an address-discriminated value.
10626 if (FT.hasAddressDiscriminatedPointerAuth()) {
10627 PrintDiagAndRemoveAttr(6);
10628 return;
10629 }
10630
10631 if (const auto *RT =
10632 FT->getBaseElementTypeUnsafe()->getAsCanonical<RecordType>())
10633 if (!RT->isDependentType() &&
10634 !cast<CXXRecordDecl>(Val: RT->getDecl()->getDefinitionOrSelf())
10635 ->canPassInRegisters()) {
10636 PrintDiagAndRemoveAttr(5);
10637 return;
10638 }
10639 }
10640
10641 if (IsCXXTriviallyRelocatableType(RD))
10642 return;
10643
10644 // Ill-formed if the copy and move constructors are deleted.
10645 auto HasNonDeletedCopyOrMoveConstructor = [&]() {
10646 // If the type is dependent, then assume it might have
10647 // implicit copy or move ctor because we won't know yet at this point.
10648 if (RD.isDependentType())
10649 return true;
10650 if (RD.needsImplicitCopyConstructor() &&
10651 !RD.defaultedCopyConstructorIsDeleted())
10652 return true;
10653 if (RD.needsImplicitMoveConstructor() &&
10654 !RD.defaultedMoveConstructorIsDeleted())
10655 return true;
10656 for (const CXXConstructorDecl *CD : RD.ctors())
10657 if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
10658 return true;
10659 return false;
10660 };
10661
10662 if (!HasNonDeletedCopyOrMoveConstructor()) {
10663 PrintDiagAndRemoveAttr(0);
10664 return;
10665 }
10666}
10667
10668void Sema::checkIncorrectVTablePointerAuthenticationAttribute(
10669 CXXRecordDecl &RD) {
10670 if (RequireCompleteType(Loc: RD.getLocation(), T: Context.getCanonicalTagType(TD: &RD),
10671 DiagID: diag::err_incomplete_type_vtable_pointer_auth))
10672 return;
10673
10674 const CXXRecordDecl *PrimaryBase = &RD;
10675 if (PrimaryBase->hasAnyDependentBases())
10676 return;
10677
10678 while (1) {
10679 assert(PrimaryBase);
10680 const CXXRecordDecl *Base = nullptr;
10681 for (const CXXBaseSpecifier &BasePtr : PrimaryBase->bases()) {
10682 if (!BasePtr.getType()->getAsCXXRecordDecl()->isDynamicClass())
10683 continue;
10684 Base = BasePtr.getType()->getAsCXXRecordDecl();
10685 break;
10686 }
10687 if (!Base || Base == PrimaryBase || !Base->isPolymorphic())
10688 break;
10689 Diag(Loc: RD.getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10690 DiagID: diag::err_non_top_level_vtable_pointer_auth)
10691 << &RD << Base;
10692 PrimaryBase = Base;
10693 }
10694
10695 if (!RD.isPolymorphic())
10696 Diag(Loc: RD.getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10697 DiagID: diag::err_non_polymorphic_vtable_pointer_auth)
10698 << &RD;
10699}
10700
10701void Sema::ActOnFinishCXXMemberSpecification(
10702 Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac,
10703 SourceLocation RBrac, const ParsedAttributesView &AttrList) {
10704 if (!TagDecl)
10705 return;
10706
10707 AdjustDeclIfTemplate(Decl&: TagDecl);
10708
10709 for (const ParsedAttr &AL : AttrList) {
10710 if (AL.getKind() != ParsedAttr::AT_Visibility)
10711 continue;
10712 AL.setInvalid();
10713 Diag(Loc: AL.getLoc(), DiagID: diag::warn_attribute_after_definition_ignored) << AL;
10714 }
10715
10716 ActOnFields(S, RecLoc: RLoc, TagDecl,
10717 Fields: llvm::ArrayRef(
10718 // strict aliasing violation!
10719 reinterpret_cast<Decl **>(FieldCollector->getCurFields()),
10720 FieldCollector->getCurNumFields()),
10721 LBrac, RBrac, AttrList);
10722
10723 CheckCompletedCXXClass(S, Record: cast<CXXRecordDecl>(Val: TagDecl));
10724}
10725
10726/// Find the equality comparison functions that should be implicitly declared
10727/// in a given class definition, per C++2a [class.compare.default]p3.
10728static void findImplicitlyDeclaredEqualityComparisons(
10729 ASTContext &Ctx, CXXRecordDecl *RD,
10730 llvm::SmallVectorImpl<FunctionDecl *> &Spaceships) {
10731 DeclarationName EqEq = Ctx.DeclarationNames.getCXXOperatorName(Op: OO_EqualEqual);
10732 if (!RD->lookup(Name: EqEq).empty())
10733 // Member operator== explicitly declared: no implicit operator==s.
10734 return;
10735
10736 // Traverse friends looking for an '==' or a '<=>'.
10737 for (FriendDecl *Friend : RD->friends()) {
10738 FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Val: Friend->getFriendDecl());
10739 if (!FD) continue;
10740
10741 if (FD->getOverloadedOperator() == OO_EqualEqual) {
10742 // Friend operator== explicitly declared: no implicit operator==s.
10743 Spaceships.clear();
10744 return;
10745 }
10746
10747 if (FD->getOverloadedOperator() == OO_Spaceship &&
10748 FD->isExplicitlyDefaulted())
10749 Spaceships.push_back(Elt: FD);
10750 }
10751
10752 // Look for members named 'operator<=>'.
10753 DeclarationName Cmp = Ctx.DeclarationNames.getCXXOperatorName(Op: OO_Spaceship);
10754 for (NamedDecl *ND : RD->lookup(Name: Cmp)) {
10755 // Note that we could find a non-function here (either a function template
10756 // or a using-declaration). Neither case results in an implicit
10757 // 'operator=='.
10758 if (auto *FD = dyn_cast<FunctionDecl>(Val: ND))
10759 if (FD->isExplicitlyDefaulted())
10760 Spaceships.push_back(Elt: FD);
10761 }
10762}
10763
10764void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
10765 // Don't add implicit special members to templated classes.
10766 // FIXME: This means unqualified lookups for 'operator=' within a class
10767 // template don't work properly.
10768 if (!ClassDecl->isDependentType()) {
10769 if (ClassDecl->needsImplicitDefaultConstructor()) {
10770 ++getASTContext().NumImplicitDefaultConstructors;
10771
10772 if (ClassDecl->hasInheritedConstructor())
10773 DeclareImplicitDefaultConstructor(ClassDecl);
10774 }
10775
10776 if (ClassDecl->needsImplicitCopyConstructor()) {
10777 ++getASTContext().NumImplicitCopyConstructors;
10778
10779 // If the properties or semantics of the copy constructor couldn't be
10780 // determined while the class was being declared, force a declaration
10781 // of it now.
10782 if (ClassDecl->needsOverloadResolutionForCopyConstructor() ||
10783 ClassDecl->hasInheritedConstructor())
10784 DeclareImplicitCopyConstructor(ClassDecl);
10785 // For the MS ABI we need to know whether the copy ctor is deleted. A
10786 // prerequisite for deleting the implicit copy ctor is that the class has
10787 // a move ctor or move assignment that is either user-declared or whose
10788 // semantics are inherited from a subobject. FIXME: We should provide a
10789 // more direct way for CodeGen to ask whether the constructor was deleted.
10790 else if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
10791 (ClassDecl->hasUserDeclaredMoveConstructor() ||
10792 ClassDecl->needsOverloadResolutionForMoveConstructor() ||
10793 ClassDecl->hasUserDeclaredMoveAssignment() ||
10794 ClassDecl->needsOverloadResolutionForMoveAssignment()))
10795 DeclareImplicitCopyConstructor(ClassDecl);
10796 }
10797
10798 if (getLangOpts().CPlusPlus11 &&
10799 ClassDecl->needsImplicitMoveConstructor()) {
10800 ++getASTContext().NumImplicitMoveConstructors;
10801
10802 if (ClassDecl->needsOverloadResolutionForMoveConstructor() ||
10803 ClassDecl->hasInheritedConstructor())
10804 DeclareImplicitMoveConstructor(ClassDecl);
10805 }
10806
10807 if (ClassDecl->needsImplicitCopyAssignment()) {
10808 ++getASTContext().NumImplicitCopyAssignmentOperators;
10809
10810 // If we have a dynamic class, then the copy assignment operator may be
10811 // virtual, so we have to declare it immediately. This ensures that, e.g.,
10812 // it shows up in the right place in the vtable and that we diagnose
10813 // problems with the implicit exception specification.
10814 if (ClassDecl->isDynamicClass() ||
10815 ClassDecl->needsOverloadResolutionForCopyAssignment() ||
10816 ClassDecl->hasInheritedAssignment())
10817 DeclareImplicitCopyAssignment(ClassDecl);
10818 }
10819
10820 if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
10821 ++getASTContext().NumImplicitMoveAssignmentOperators;
10822
10823 // Likewise for the move assignment operator.
10824 if (ClassDecl->isDynamicClass() ||
10825 ClassDecl->needsOverloadResolutionForMoveAssignment() ||
10826 ClassDecl->hasInheritedAssignment())
10827 DeclareImplicitMoveAssignment(ClassDecl);
10828 }
10829
10830 if (ClassDecl->needsImplicitDestructor()) {
10831 ++getASTContext().NumImplicitDestructors;
10832
10833 // If we have a dynamic class, then the destructor may be virtual, so we
10834 // have to declare the destructor immediately. This ensures that, e.g., it
10835 // shows up in the right place in the vtable and that we diagnose problems
10836 // with the implicit exception specification.
10837 if (ClassDecl->isDynamicClass() ||
10838 ClassDecl->needsOverloadResolutionForDestructor())
10839 DeclareImplicitDestructor(ClassDecl);
10840 }
10841 }
10842
10843 // C++2a [class.compare.default]p3:
10844 // If the member-specification does not explicitly declare any member or
10845 // friend named operator==, an == operator function is declared implicitly
10846 // for each defaulted three-way comparison operator function defined in
10847 // the member-specification
10848 // FIXME: Consider doing this lazily.
10849 // We do this during the initial parse for a class template, not during
10850 // instantiation, so that we can handle unqualified lookups for 'operator=='
10851 // when parsing the template.
10852 if (getLangOpts().CPlusPlus20 && !inTemplateInstantiation()) {
10853 llvm::SmallVector<FunctionDecl *, 4> DefaultedSpaceships;
10854 findImplicitlyDeclaredEqualityComparisons(Ctx&: Context, RD: ClassDecl,
10855 Spaceships&: DefaultedSpaceships);
10856 for (auto *FD : DefaultedSpaceships)
10857 DeclareImplicitEqualityComparison(RD: ClassDecl, Spaceship: FD);
10858 }
10859}
10860
10861unsigned
10862Sema::ActOnReenterTemplateScope(Decl *D,
10863 llvm::function_ref<Scope *()> EnterScope) {
10864 if (!D)
10865 return 0;
10866 AdjustDeclIfTemplate(Decl&: D);
10867
10868 // In order to get name lookup right, reenter template scopes in order from
10869 // outermost to innermost.
10870 SmallVector<TemplateParameterList *, 4> ParameterLists;
10871 DeclContext *LookupDC = dyn_cast<DeclContext>(Val: D);
10872
10873 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(Val: D)) {
10874 for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
10875 ParameterLists.push_back(Elt: DD->getTemplateParameterList(index: i));
10876
10877 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Val: D)) {
10878 if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
10879 ParameterLists.push_back(Elt: FTD->getTemplateParameters());
10880 } else if (VarDecl *VD = dyn_cast<VarDecl>(Val: D)) {
10881 LookupDC = VD->getDeclContext();
10882
10883 if (VarTemplateDecl *VTD = VD->getDescribedVarTemplate())
10884 ParameterLists.push_back(Elt: VTD->getTemplateParameters());
10885 else if (auto *PSD = dyn_cast<VarTemplatePartialSpecializationDecl>(Val: D))
10886 ParameterLists.push_back(Elt: PSD->getTemplateParameters());
10887 }
10888 } else if (TagDecl *TD = dyn_cast<TagDecl>(Val: D)) {
10889 for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
10890 ParameterLists.push_back(Elt: TD->getTemplateParameterList(i));
10891
10892 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Val: TD)) {
10893 if (ClassTemplateDecl *CTD = RD->getDescribedClassTemplate())
10894 ParameterLists.push_back(Elt: CTD->getTemplateParameters());
10895 else if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(Val: D))
10896 ParameterLists.push_back(Elt: PSD->getTemplateParameters());
10897 }
10898 }
10899 // FIXME: Alias declarations and concepts.
10900
10901 unsigned Count = 0;
10902 Scope *InnermostTemplateScope = nullptr;
10903 for (TemplateParameterList *Params : ParameterLists) {
10904 // Ignore explicit specializations; they don't contribute to the template
10905 // depth.
10906 if (Params->size() == 0)
10907 continue;
10908
10909 InnermostTemplateScope = EnterScope();
10910 for (NamedDecl *Param : *Params) {
10911 if (Param->getDeclName()) {
10912 InnermostTemplateScope->AddDecl(D: Param);
10913 IdResolver.AddDecl(D: Param);
10914 }
10915 }
10916 ++Count;
10917 }
10918
10919 // Associate the new template scopes with the corresponding entities.
10920 if (InnermostTemplateScope) {
10921 assert(LookupDC && "no enclosing DeclContext for template lookup");
10922 EnterTemplatedContext(S: InnermostTemplateScope, DC: LookupDC);
10923 }
10924
10925 return Count;
10926}
10927
10928void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
10929 if (!RecordD) return;
10930 AdjustDeclIfTemplate(Decl&: RecordD);
10931 CXXRecordDecl *Record = cast<CXXRecordDecl>(Val: RecordD);
10932 PushDeclContext(S, DC: Record);
10933}
10934
10935void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
10936 if (!RecordD) return;
10937 PopDeclContext();
10938}
10939
10940void Sema::ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param) {
10941 if (!Param)
10942 return;
10943
10944 S->AddDecl(D: Param);
10945 if (Param->getDeclName())
10946 IdResolver.AddDecl(D: Param);
10947}
10948
10949void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
10950}
10951
10952/// ActOnDelayedCXXMethodParameter - We've already started a delayed
10953/// C++ method declaration. We're (re-)introducing the given
10954/// function parameter into scope for use in parsing later parts of
10955/// the method declaration. For example, we could see an
10956/// ActOnParamDefaultArgument event for this parameter.
10957void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) {
10958 if (!ParamD)
10959 return;
10960
10961 ParmVarDecl *Param = cast<ParmVarDecl>(Val: ParamD);
10962
10963 S->AddDecl(D: Param);
10964 if (Param->getDeclName())
10965 IdResolver.AddDecl(D: Param);
10966}
10967
10968void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
10969 if (!MethodD)
10970 return;
10971
10972 AdjustDeclIfTemplate(Decl&: MethodD);
10973
10974 FunctionDecl *Method = cast<FunctionDecl>(Val: MethodD);
10975
10976 // Now that we have our default arguments, check the constructor
10977 // again. It could produce additional diagnostics or affect whether
10978 // the class has implicitly-declared destructors, among other
10979 // things.
10980 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Val: Method))
10981 CheckConstructor(Constructor);
10982
10983 // Check the default arguments, which we may have added.
10984 if (!Method->isInvalidDecl())
10985 CheckCXXDefaultArguments(FD: Method);
10986}
10987
10988// Emit the given diagnostic for each non-address-space qualifier.
10989// Common part of CheckConstructorDeclarator and CheckDestructorDeclarator.
10990static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID) {
10991 const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
10992 if (FTI.hasMethodTypeQualifiers() && !D.isInvalidType()) {
10993 bool DiagOccurred = false;
10994 FTI.MethodQualifiers->forEachQualifier(
10995 Handle: [DiagID, &S, &DiagOccurred](DeclSpec::TQ, StringRef QualName,
10996 SourceLocation SL) {
10997 // This diagnostic should be emitted on any qualifier except an addr
10998 // space qualifier. However, forEachQualifier currently doesn't visit
10999 // addr space qualifiers, so there's no way to write this condition
11000 // right now; we just diagnose on everything.
11001 S.Diag(Loc: SL, DiagID) << QualName << SourceRange(SL);
11002 DiagOccurred = true;
11003 });
11004 if (DiagOccurred)
11005 D.setInvalidType();
11006 }
11007}
11008
11009static void diagnoseInvalidDeclaratorChunks(Sema &S, Declarator &D,
11010 unsigned Kind) {
11011 if (D.isInvalidType() || D.getNumTypeObjects() <= 1)
11012 return;
11013
11014 DeclaratorChunk &Chunk = D.getTypeObject(i: D.getNumTypeObjects() - 1);
11015 if (Chunk.Kind == DeclaratorChunk::Paren ||
11016 Chunk.Kind == DeclaratorChunk::Function)
11017 return;
11018
11019 SourceLocation PointerLoc = Chunk.getSourceRange().getBegin();
11020 S.Diag(Loc: PointerLoc, DiagID: diag::err_invalid_ctor_dtor_decl)
11021 << Kind << Chunk.getSourceRange();
11022 D.setInvalidType();
11023}
11024
11025QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
11026 StorageClass &SC) {
11027 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
11028
11029 // C++ [class.ctor]p3:
11030 // A constructor shall not be virtual (10.3) or static (9.4). A
11031 // constructor can be invoked for a const, volatile or const
11032 // volatile object. A constructor shall not be declared const,
11033 // volatile, or const volatile (9.3.2).
11034 if (isVirtual) {
11035 if (!D.isInvalidType())
11036 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_constructor_cannot_be)
11037 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
11038 << SourceRange(D.getIdentifierLoc());
11039 D.setInvalidType();
11040 }
11041 if (SC == SC_Static) {
11042 if (!D.isInvalidType())
11043 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_constructor_cannot_be)
11044 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
11045 << SourceRange(D.getIdentifierLoc());
11046 D.setInvalidType();
11047 SC = SC_None;
11048 }
11049
11050 if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
11051 diagnoseIgnoredQualifiers(
11052 DiagID: diag::err_constructor_return_type, Quals: TypeQuals, FallbackLoc: SourceLocation(),
11053 ConstQualLoc: D.getDeclSpec().getConstSpecLoc(), VolatileQualLoc: D.getDeclSpec().getVolatileSpecLoc(),
11054 RestrictQualLoc: D.getDeclSpec().getRestrictSpecLoc(),
11055 AtomicQualLoc: D.getDeclSpec().getAtomicSpecLoc());
11056 D.setInvalidType();
11057 }
11058
11059 checkMethodTypeQualifiers(S&: *this, D, DiagID: diag::err_invalid_qualified_constructor);
11060 diagnoseInvalidDeclaratorChunks(S&: *this, D, /*constructor*/ Kind: 0);
11061
11062 // C++0x [class.ctor]p4:
11063 // A constructor shall not be declared with a ref-qualifier.
11064 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11065 if (FTI.hasRefQualifier()) {
11066 Diag(Loc: FTI.getRefQualifierLoc(), DiagID: diag::err_ref_qualifier_constructor)
11067 << FTI.RefQualifierIsLValueRef
11068 << FixItHint::CreateRemoval(RemoveRange: FTI.getRefQualifierLoc());
11069 D.setInvalidType();
11070 }
11071
11072 // Rebuild the function type "R" without any type qualifiers (in
11073 // case any of the errors above fired) and with "void" as the
11074 // return type, since constructors don't have return types.
11075 const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
11076 if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
11077 return R;
11078
11079 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
11080 EPI.TypeQuals = Qualifiers();
11081 EPI.RefQualifier = RQ_None;
11082
11083 return Context.getFunctionType(ResultTy: Context.VoidTy, Args: Proto->getParamTypes(), EPI);
11084}
11085
11086void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
11087 CXXRecordDecl *ClassDecl
11088 = dyn_cast<CXXRecordDecl>(Val: Constructor->getDeclContext());
11089 if (!ClassDecl)
11090 return Constructor->setInvalidDecl();
11091
11092 // C++ [class.copy]p3:
11093 // A declaration of a constructor for a class X is ill-formed if
11094 // its first parameter is of type (optionally cv-qualified) X and
11095 // either there are no other parameters or else all other
11096 // parameters have default arguments.
11097 if (!Constructor->isInvalidDecl() &&
11098 Constructor->hasOneParamOrDefaultArgs() &&
11099 !Constructor->isFunctionTemplateSpecialization()) {
11100 CanQualType ParamType =
11101 Constructor->getParamDecl(i: 0)->getType()->getCanonicalTypeUnqualified();
11102 CanQualType ClassTy = Context.getCanonicalTagType(TD: ClassDecl);
11103 if (ParamType == ClassTy) {
11104 SourceLocation ParamLoc = Constructor->getParamDecl(i: 0)->getLocation();
11105 const char *ConstRef
11106 = Constructor->getParamDecl(i: 0)->getIdentifier() ? "const &"
11107 : " const &";
11108 Diag(Loc: ParamLoc, DiagID: diag::err_constructor_byvalue_arg)
11109 << FixItHint::CreateInsertion(InsertionLoc: ParamLoc, Code: ConstRef);
11110
11111 // FIXME: Rather that making the constructor invalid, we should endeavor
11112 // to fix the type.
11113 Constructor->setInvalidDecl();
11114 }
11115 }
11116}
11117
11118bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
11119 CXXRecordDecl *RD = Destructor->getParent();
11120
11121 if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
11122 SourceLocation Loc;
11123
11124 if (!Destructor->isImplicit())
11125 Loc = Destructor->getLocation();
11126 else
11127 Loc = RD->getLocation();
11128
11129 DeclarationName Name =
11130 Context.DeclarationNames.getCXXOperatorName(Op: OO_Delete);
11131 // If we have a virtual destructor, look up the deallocation function
11132 if (FunctionDecl *OperatorDelete = FindDeallocationFunctionForDestructor(
11133 StartLoc: Loc, RD, /*Diagnose=*/true, /*LookForGlobal=*/false, Name)) {
11134 Expr *ThisArg = nullptr;
11135
11136 // If the notional 'delete this' expression requires a non-trivial
11137 // conversion from 'this' to the type of a destroying operator delete's
11138 // first parameter, perform that conversion now.
11139 if (OperatorDelete->isDestroyingOperatorDelete()) {
11140 unsigned AddressParamIndex = 0;
11141 if (OperatorDelete->isTypeAwareOperatorNewOrDelete())
11142 ++AddressParamIndex;
11143 QualType ParamType =
11144 OperatorDelete->getParamDecl(i: AddressParamIndex)->getType();
11145 if (!declaresSameEntity(D1: ParamType->getAsCXXRecordDecl(), D2: RD)) {
11146 // C++ [class.dtor]p13:
11147 // ... as if for the expression 'delete this' appearing in a
11148 // non-virtual destructor of the destructor's class.
11149 ContextRAII SwitchContext(*this, Destructor);
11150 ExprResult This = ActOnCXXThis(
11151 Loc: OperatorDelete->getParamDecl(i: AddressParamIndex)->getLocation());
11152 assert(!This.isInvalid() && "couldn't form 'this' expr in dtor?");
11153 This = PerformImplicitConversion(From: This.get(), ToType: ParamType,
11154 Action: AssignmentAction::Passing);
11155 if (This.isInvalid()) {
11156 // FIXME: Register this as a context note so that it comes out
11157 // in the right order.
11158 Diag(Loc, DiagID: diag::note_implicit_delete_this_in_destructor_here);
11159 return true;
11160 }
11161 ThisArg = This.get();
11162 }
11163 }
11164
11165 DiagnoseUseOfDecl(D: OperatorDelete, Locs: Loc);
11166 MarkFunctionReferenced(Loc, Func: OperatorDelete);
11167 Destructor->setOperatorDelete(OD: OperatorDelete, ThisArg);
11168
11169 if (isa<CXXMethodDecl>(Val: OperatorDelete) &&
11170 Context.getTargetInfo().callGlobalDeleteInDeletingDtor(
11171 Context.getLangOpts())) {
11172 // In Microsoft ABI whenever a class has a defined operator delete,
11173 // scalar deleting destructors check the 3rd bit of the implicit
11174 // parameter and if it is set, then, global operator delete must be
11175 // called instead of the class-specific one. Find and save the global
11176 // operator delete for that case. Do not diagnose at this point because
11177 // the lack of a global operator delete is not an error if there are no
11178 // delete calls that require it.
11179 FunctionDecl *GlobalOperatorDelete =
11180 FindDeallocationFunctionForDestructor(StartLoc: Loc, RD, /*Diagnose*/ false,
11181 /*LookForGlobal*/ true, Name);
11182 if (GlobalOperatorDelete) {
11183 MarkFunctionReferenced(Loc, Func: GlobalOperatorDelete);
11184 Destructor->setOperatorGlobalDelete(GlobalOperatorDelete);
11185 }
11186 }
11187
11188 if (Context.getTargetInfo().emitVectorDeletingDtors(
11189 Context.getLangOpts())) {
11190 // Lookup delete[] too in case we have to emit a vector deleting dtor.
11191 DeclarationName VDeleteName =
11192 Context.DeclarationNames.getCXXOperatorName(Op: OO_Array_Delete);
11193 FunctionDecl *ArrOperatorDelete = FindDeallocationFunctionForDestructor(
11194 StartLoc: Loc, RD, /*Diagnose*/ false,
11195 /*LookForGlobal*/ false, Name: VDeleteName);
11196 if (ArrOperatorDelete && isa<CXXMethodDecl>(Val: ArrOperatorDelete)) {
11197 FunctionDecl *GlobalArrOperatorDelete =
11198 FindDeallocationFunctionForDestructor(StartLoc: Loc, RD, /*Diagnose*/ false,
11199 /*LookForGlobal*/ true,
11200 Name: VDeleteName);
11201 Destructor->setGlobalOperatorArrayDelete(GlobalArrOperatorDelete);
11202 if (GlobalArrOperatorDelete &&
11203 Context.classNeedsVectorDeletingDestructor(RD))
11204 MarkFunctionReferenced(Loc, Func: GlobalArrOperatorDelete);
11205 } else if (!ArrOperatorDelete) {
11206 ArrOperatorDelete = FindDeallocationFunctionForDestructor(
11207 StartLoc: Loc, RD, /*Diagnose*/ false,
11208 /*LookForGlobal*/ true, Name: VDeleteName);
11209 }
11210 Destructor->setOperatorArrayDelete(ArrOperatorDelete);
11211 if (ArrOperatorDelete && Context.classNeedsVectorDeletingDestructor(RD))
11212 MarkFunctionReferenced(Loc, Func: ArrOperatorDelete);
11213 }
11214 }
11215 }
11216
11217 return false;
11218}
11219
11220QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
11221 StorageClass& SC) {
11222 // C++ [class.dtor]p1:
11223 // [...] A typedef-name that names a class is a class-name
11224 // (7.1.3); however, a typedef-name that names a class shall not
11225 // be used as the identifier in the declarator for a destructor
11226 // declaration.
11227 QualType DeclaratorType = GetTypeFromParser(Ty: D.getName().DestructorName);
11228 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
11229 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::ext_destructor_typedef_name)
11230 << DeclaratorType << isa<TypeAliasDecl>(Val: TT->getDecl());
11231 else if (const TemplateSpecializationType *TST =
11232 DeclaratorType->getAs<TemplateSpecializationType>())
11233 if (TST->isTypeAlias())
11234 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::ext_destructor_typedef_name)
11235 << DeclaratorType << 1;
11236
11237 // C++ [class.dtor]p2:
11238 // A destructor is used to destroy objects of its class type. A
11239 // destructor takes no parameters, and no return type can be
11240 // specified for it (not even void). The address of a destructor
11241 // shall not be taken. A destructor shall not be static. A
11242 // destructor can be invoked for a const, volatile or const
11243 // volatile object. A destructor shall not be declared const,
11244 // volatile or const volatile (9.3.2).
11245 if (SC == SC_Static) {
11246 if (!D.isInvalidType())
11247 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_destructor_cannot_be)
11248 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
11249 << SourceRange(D.getIdentifierLoc())
11250 << FixItHint::CreateRemoval(RemoveRange: D.getDeclSpec().getStorageClassSpecLoc());
11251
11252 SC = SC_None;
11253 }
11254 if (!D.isInvalidType()) {
11255 // Destructors don't have return types, but the parser will
11256 // happily parse something like:
11257 //
11258 // class X {
11259 // float ~X();
11260 // };
11261 //
11262 // The return type will be eliminated later.
11263 if (D.getDeclSpec().hasTypeSpecifier())
11264 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_destructor_return_type)
11265 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
11266 << SourceRange(D.getIdentifierLoc());
11267 else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
11268 diagnoseIgnoredQualifiers(DiagID: diag::err_destructor_return_type, Quals: TypeQuals,
11269 FallbackLoc: SourceLocation(),
11270 ConstQualLoc: D.getDeclSpec().getConstSpecLoc(),
11271 VolatileQualLoc: D.getDeclSpec().getVolatileSpecLoc(),
11272 RestrictQualLoc: D.getDeclSpec().getRestrictSpecLoc(),
11273 AtomicQualLoc: D.getDeclSpec().getAtomicSpecLoc());
11274 D.setInvalidType();
11275 }
11276 }
11277
11278 checkMethodTypeQualifiers(S&: *this, D, DiagID: diag::err_invalid_qualified_destructor);
11279 diagnoseInvalidDeclaratorChunks(S&: *this, D, /*destructor*/ Kind: 1);
11280
11281 // C++0x [class.dtor]p2:
11282 // A destructor shall not be declared with a ref-qualifier.
11283 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11284 if (FTI.hasRefQualifier()) {
11285 Diag(Loc: FTI.getRefQualifierLoc(), DiagID: diag::err_ref_qualifier_destructor)
11286 << FTI.RefQualifierIsLValueRef
11287 << FixItHint::CreateRemoval(RemoveRange: FTI.getRefQualifierLoc());
11288 D.setInvalidType();
11289 }
11290
11291 // Make sure we don't have any parameters.
11292 if (FTIHasNonVoidParameters(FTI)) {
11293 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_destructor_with_params);
11294
11295 // Delete the parameters.
11296 FTI.freeParams();
11297 D.setInvalidType();
11298 }
11299
11300 // Make sure the destructor isn't variadic.
11301 if (FTI.isVariadic) {
11302 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_destructor_variadic);
11303 D.setInvalidType();
11304 }
11305
11306 // Rebuild the function type "R" without any type qualifiers or
11307 // parameters (in case any of the errors above fired) and with
11308 // "void" as the return type, since destructors don't have return
11309 // types.
11310 if (!D.isInvalidType())
11311 return R;
11312
11313 const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
11314 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
11315 EPI.Variadic = false;
11316 EPI.TypeQuals = Qualifiers();
11317 EPI.RefQualifier = RQ_None;
11318 return Context.getFunctionType(ResultTy: Context.VoidTy, Args: {}, EPI);
11319}
11320
11321static void extendLeft(SourceRange &R, SourceRange Before) {
11322 if (Before.isInvalid())
11323 return;
11324 R.setBegin(Before.getBegin());
11325 if (R.getEnd().isInvalid())
11326 R.setEnd(Before.getEnd());
11327}
11328
11329static void extendRight(SourceRange &R, SourceRange After) {
11330 if (After.isInvalid())
11331 return;
11332 if (R.getBegin().isInvalid())
11333 R.setBegin(After.getBegin());
11334 R.setEnd(After.getEnd());
11335}
11336
11337void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
11338 StorageClass& SC) {
11339 // C++ [class.conv.fct]p1:
11340 // Neither parameter types nor return type can be specified. The
11341 // type of a conversion function (8.3.5) is "function taking no
11342 // parameter returning conversion-type-id."
11343 if (SC == SC_Static) {
11344 if (!D.isInvalidType())
11345 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_conv_function_not_member)
11346 << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
11347 << D.getName().getSourceRange();
11348 D.setInvalidType();
11349 SC = SC_None;
11350 }
11351
11352 TypeSourceInfo *ConvTSI = nullptr;
11353 QualType ConvType =
11354 GetTypeFromParser(Ty: D.getName().ConversionFunctionId, TInfo: &ConvTSI);
11355
11356 const DeclSpec &DS = D.getDeclSpec();
11357 if (DS.hasTypeSpecifier() && !D.isInvalidType()) {
11358 // Conversion functions don't have return types, but the parser will
11359 // happily parse something like:
11360 //
11361 // class X {
11362 // float operator bool();
11363 // };
11364 //
11365 // The return type will be changed later anyway.
11366 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_conv_function_return_type)
11367 << SourceRange(DS.getTypeSpecTypeLoc())
11368 << SourceRange(D.getIdentifierLoc());
11369 D.setInvalidType();
11370 } else if (DS.getTypeQualifiers() && !D.isInvalidType()) {
11371 // It's also plausible that the user writes type qualifiers in the wrong
11372 // place, such as:
11373 // struct S { const operator int(); };
11374 // FIXME: we could provide a fixit to move the qualifiers onto the
11375 // conversion type.
11376 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_conv_function_with_complex_decl)
11377 << SourceRange(D.getIdentifierLoc()) << 0;
11378 D.setInvalidType();
11379 }
11380 const auto *Proto = R->castAs<FunctionProtoType>();
11381 // Make sure we don't have any parameters.
11382 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11383 unsigned NumParam = Proto->getNumParams();
11384
11385 // [C++2b]
11386 // A conversion function shall have no non-object parameters.
11387 if (NumParam == 1) {
11388 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11389 if (const auto *First =
11390 dyn_cast_if_present<ParmVarDecl>(Val: FTI.Params[0].Param);
11391 First && First->isExplicitObjectParameter())
11392 NumParam--;
11393 }
11394
11395 if (NumParam != 0) {
11396 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_conv_function_with_params);
11397 // Delete the parameters.
11398 FTI.freeParams();
11399 D.setInvalidType();
11400 } else if (Proto->isVariadic()) {
11401 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_conv_function_variadic);
11402 D.setInvalidType();
11403 }
11404
11405 // Diagnose "&operator bool()" and other such nonsense. This
11406 // is actually a gcc extension which we don't support.
11407 if (Proto->getReturnType() != ConvType) {
11408 bool NeedsTypedef = false;
11409 SourceRange Before, After;
11410
11411 // Walk the chunks and extract information on them for our diagnostic.
11412 bool PastFunctionChunk = false;
11413 for (auto &Chunk : D.type_objects()) {
11414 switch (Chunk.Kind) {
11415 case DeclaratorChunk::Function:
11416 if (!PastFunctionChunk) {
11417 if (Chunk.Fun.HasTrailingReturnType) {
11418 TypeSourceInfo *TRT = nullptr;
11419 GetTypeFromParser(Ty: Chunk.Fun.getTrailingReturnType(), TInfo: &TRT);
11420 if (TRT) extendRight(R&: After, After: TRT->getTypeLoc().getSourceRange());
11421 }
11422 PastFunctionChunk = true;
11423 break;
11424 }
11425 [[fallthrough]];
11426 case DeclaratorChunk::Array:
11427 NeedsTypedef = true;
11428 extendRight(R&: After, After: Chunk.getSourceRange());
11429 break;
11430
11431 case DeclaratorChunk::Pointer:
11432 case DeclaratorChunk::BlockPointer:
11433 case DeclaratorChunk::Reference:
11434 case DeclaratorChunk::MemberPointer:
11435 case DeclaratorChunk::Pipe:
11436 extendLeft(R&: Before, Before: Chunk.getSourceRange());
11437 break;
11438
11439 case DeclaratorChunk::Paren:
11440 extendLeft(R&: Before, Before: Chunk.Loc);
11441 extendRight(R&: After, After: Chunk.EndLoc);
11442 break;
11443 }
11444 }
11445
11446 SourceLocation Loc = Before.isValid() ? Before.getBegin() :
11447 After.isValid() ? After.getBegin() :
11448 D.getIdentifierLoc();
11449 auto &&DB = Diag(Loc, DiagID: diag::err_conv_function_with_complex_decl);
11450 DB << Before << After;
11451
11452 if (!NeedsTypedef) {
11453 DB << /*don't need a typedef*/0;
11454
11455 // If we can provide a correct fix-it hint, do so.
11456 if (After.isInvalid() && ConvTSI) {
11457 SourceLocation InsertLoc =
11458 getLocForEndOfToken(Loc: ConvTSI->getTypeLoc().getEndLoc());
11459 DB << FixItHint::CreateInsertion(InsertionLoc: InsertLoc, Code: " ")
11460 << FixItHint::CreateInsertionFromRange(
11461 InsertionLoc: InsertLoc, FromRange: CharSourceRange::getTokenRange(R: Before))
11462 << FixItHint::CreateRemoval(RemoveRange: Before);
11463 }
11464 } else if (!Proto->getReturnType()->isDependentType()) {
11465 DB << /*typedef*/1 << Proto->getReturnType();
11466 } else if (getLangOpts().CPlusPlus11) {
11467 DB << /*alias template*/2 << Proto->getReturnType();
11468 } else {
11469 DB << /*might not be fixable*/3;
11470 }
11471
11472 // Recover by incorporating the other type chunks into the result type.
11473 // Note, this does *not* change the name of the function. This is compatible
11474 // with the GCC extension:
11475 // struct S { &operator int(); } s;
11476 // int &r = s.operator int(); // ok in GCC
11477 // S::operator int&() {} // error in GCC, function name is 'operator int'.
11478 ConvType = Proto->getReturnType();
11479 }
11480
11481 // C++ [class.conv.fct]p4:
11482 // The conversion-type-id shall not represent a function type nor
11483 // an array type.
11484 if (ConvType->isArrayType()) {
11485 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_conv_function_to_array);
11486 ConvType = Context.getPointerType(T: ConvType);
11487 D.setInvalidType();
11488 } else if (ConvType->isFunctionType()) {
11489 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_conv_function_to_function);
11490 ConvType = Context.getPointerType(T: ConvType);
11491 D.setInvalidType();
11492 }
11493
11494 // Rebuild the function type "R" without any parameters (in case any
11495 // of the errors above fired) and with the conversion type as the
11496 // return type.
11497 if (D.isInvalidType())
11498 R = Context.getFunctionType(ResultTy: ConvType, Args: {}, EPI: Proto->getExtProtoInfo());
11499
11500 // C++0x explicit conversion operators.
11501 if (DS.hasExplicitSpecifier() && !getLangOpts().CPlusPlus20)
11502 Diag(Loc: DS.getExplicitSpecLoc(),
11503 DiagID: getLangOpts().CPlusPlus11
11504 ? diag::warn_cxx98_compat_explicit_conversion_functions
11505 : diag::ext_explicit_conversion_functions)
11506 << SourceRange(DS.getExplicitSpecRange());
11507}
11508
11509Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
11510 assert(Conversion && "Expected to receive a conversion function declaration");
11511
11512 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Val: Conversion->getDeclContext());
11513
11514 // Make sure we aren't redeclaring the conversion function.
11515 QualType ConvType = Context.getCanonicalType(T: Conversion->getConversionType());
11516 // C++ [class.conv.fct]p1:
11517 // [...] A conversion function is never used to convert a
11518 // (possibly cv-qualified) object to the (possibly cv-qualified)
11519 // same object type (or a reference to it), to a (possibly
11520 // cv-qualified) base class of that type (or a reference to it),
11521 // or to (possibly cv-qualified) void.
11522 CanQualType ClassType = Context.getCanonicalTagType(TD: ClassDecl);
11523 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
11524 ConvType = ConvTypeRef->getPointeeType();
11525 if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
11526 Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
11527 /* Suppress diagnostics for instantiations. */;
11528 else if (Conversion->size_overridden_methods() != 0)
11529 /* Suppress diagnostics for overriding virtual function in a base class. */;
11530 else if (ConvType->isRecordType()) {
11531 ConvType = Context.getCanonicalType(T: ConvType).getUnqualifiedType();
11532 if (ConvType == ClassType)
11533 Diag(Loc: Conversion->getLocation(), DiagID: diag::warn_conv_to_self_not_used)
11534 << ClassType;
11535 else if (IsDerivedFrom(Loc: Conversion->getLocation(), Derived: ClassType, Base: ConvType))
11536 Diag(Loc: Conversion->getLocation(), DiagID: diag::warn_conv_to_base_not_used)
11537 << ClassType << ConvType;
11538 } else if (ConvType->isVoidType()) {
11539 Diag(Loc: Conversion->getLocation(), DiagID: diag::warn_conv_to_void_not_used)
11540 << ClassType << ConvType;
11541 }
11542
11543 if (FunctionTemplateDecl *ConversionTemplate =
11544 Conversion->getDescribedFunctionTemplate()) {
11545 if (const auto *ConvTypePtr = ConvType->getAs<PointerType>()) {
11546 ConvType = ConvTypePtr->getPointeeType();
11547 }
11548 if (ConvType->isUndeducedAutoType()) {
11549 Diag(Loc: Conversion->getTypeSpecStartLoc(), DiagID: diag::err_auto_not_allowed)
11550 << getReturnTypeLoc(FD: Conversion).getSourceRange()
11551 << ConvType->castAs<AutoType>()->getKeyword()
11552 << /* in declaration of conversion function template= */ 24;
11553 }
11554
11555 return ConversionTemplate;
11556 }
11557
11558 return Conversion;
11559}
11560
11561void Sema::CheckExplicitObjectMemberFunction(DeclContext *DC, Declarator &D,
11562 DeclarationName Name, QualType R) {
11563 CheckExplicitObjectMemberFunction(D, Name, R, IsLambda: false, DC);
11564}
11565
11566void Sema::CheckExplicitObjectLambda(Declarator &D) {
11567 CheckExplicitObjectMemberFunction(D, Name: {}, R: {}, IsLambda: true);
11568}
11569
11570void Sema::CheckExplicitObjectMemberFunction(Declarator &D,
11571 DeclarationName Name, QualType R,
11572 bool IsLambda, DeclContext *DC) {
11573 if (!D.isFunctionDeclarator())
11574 return;
11575
11576 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11577 if (FTI.NumParams == 0)
11578 return;
11579 ParmVarDecl *ExplicitObjectParam = nullptr;
11580 for (unsigned Idx = 0; Idx < FTI.NumParams; Idx++) {
11581 const auto &ParamInfo = FTI.Params[Idx];
11582 if (!ParamInfo.Param)
11583 continue;
11584 ParmVarDecl *Param = cast<ParmVarDecl>(Val: ParamInfo.Param);
11585 if (!Param->isExplicitObjectParameter())
11586 continue;
11587 if (Idx == 0) {
11588 ExplicitObjectParam = Param;
11589 continue;
11590 } else {
11591 Diag(Loc: Param->getLocation(),
11592 DiagID: diag::err_explicit_object_parameter_must_be_first)
11593 << IsLambda << Param->getSourceRange();
11594 }
11595 }
11596 if (!ExplicitObjectParam)
11597 return;
11598
11599 if (ExplicitObjectParam->hasDefaultArg()) {
11600 Diag(Loc: ExplicitObjectParam->getLocation(),
11601 DiagID: diag::err_explicit_object_default_arg)
11602 << ExplicitObjectParam->getSourceRange();
11603 D.setInvalidType();
11604 }
11605
11606 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
11607 (D.getContext() == clang::DeclaratorContext::Member &&
11608 D.isStaticMember())) {
11609 Diag(Loc: ExplicitObjectParam->getBeginLoc(),
11610 DiagID: diag::err_explicit_object_parameter_nonmember)
11611 << D.getSourceRange() << /*static=*/0 << IsLambda;
11612 D.setInvalidType();
11613 }
11614
11615 if (D.getDeclSpec().isVirtualSpecified()) {
11616 Diag(Loc: ExplicitObjectParam->getBeginLoc(),
11617 DiagID: diag::err_explicit_object_parameter_nonmember)
11618 << D.getSourceRange() << /*virtual=*/1 << IsLambda;
11619 D.setInvalidType();
11620 }
11621
11622 // Friend declarations require some care. Consider:
11623 //
11624 // namespace N {
11625 // struct A{};
11626 // int f(A);
11627 // }
11628 //
11629 // struct S {
11630 // struct T {
11631 // int f(this T);
11632 // };
11633 //
11634 // friend int T::f(this T); // Allow this.
11635 // friend int f(this S); // But disallow this.
11636 // friend int N::f(this A); // And disallow this.
11637 // };
11638 //
11639 // Here, it seems to suffice to check whether the scope
11640 // specifier designates a class type.
11641 if (D.getDeclSpec().isFriendSpecified() &&
11642 !isa_and_present<CXXRecordDecl>(
11643 Val: computeDeclContext(SS: D.getCXXScopeSpec()))) {
11644 Diag(Loc: ExplicitObjectParam->getBeginLoc(),
11645 DiagID: diag::err_explicit_object_parameter_nonmember)
11646 << D.getSourceRange() << /*non-member=*/2 << IsLambda;
11647 D.setInvalidType();
11648 }
11649
11650 if (IsLambda && FTI.hasMutableQualifier()) {
11651 Diag(Loc: ExplicitObjectParam->getBeginLoc(),
11652 DiagID: diag::err_explicit_object_parameter_mutable)
11653 << D.getSourceRange();
11654 }
11655
11656 if (IsLambda)
11657 return;
11658
11659 if (!DC || !DC->isRecord()) {
11660 assert(D.isInvalidType() && "Explicit object parameter in non-member "
11661 "should have been diagnosed already");
11662 return;
11663 }
11664
11665 // CWG2674: constructors and destructors cannot have explicit parameters.
11666 if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
11667 Name.getNameKind() == DeclarationName::CXXDestructorName) {
11668 Diag(Loc: ExplicitObjectParam->getBeginLoc(),
11669 DiagID: diag::err_explicit_object_parameter_constructor)
11670 << (Name.getNameKind() == DeclarationName::CXXDestructorName)
11671 << D.getSourceRange();
11672 D.setInvalidType();
11673 }
11674}
11675
11676namespace {
11677/// Utility class to accumulate and print a diagnostic listing the invalid
11678/// specifier(s) on a declaration.
11679struct BadSpecifierDiagnoser {
11680 BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
11681 : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
11682 ~BadSpecifierDiagnoser() {
11683 Diagnostic << Specifiers;
11684 }
11685
11686 template<typename T> void check(SourceLocation SpecLoc, T Spec) {
11687 return check(SpecLoc, DeclSpec::getSpecifierName(Spec));
11688 }
11689 void check(SourceLocation SpecLoc, DeclSpec::TST Spec) {
11690 return check(SpecLoc,
11691 Spec: DeclSpec::getSpecifierName(T: Spec, Policy: S.getPrintingPolicy()));
11692 }
11693 void check(SourceLocation SpecLoc, const char *Spec) {
11694 if (SpecLoc.isInvalid()) return;
11695 Diagnostic << SourceRange(SpecLoc, SpecLoc);
11696 if (!Specifiers.empty()) Specifiers += " ";
11697 Specifiers += Spec;
11698 }
11699
11700 Sema &S;
11701 Sema::SemaDiagnosticBuilder Diagnostic;
11702 std::string Specifiers;
11703};
11704}
11705
11706bool Sema::CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
11707 StorageClass &SC) {
11708 TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
11709 TemplateDecl *GuidedTemplateDecl = GuidedTemplate.getAsTemplateDecl();
11710 assert(GuidedTemplateDecl && "missing template decl for deduction guide");
11711
11712 // C++ [temp.deduct.guide]p3:
11713 // A deduction-gide shall be declared in the same scope as the
11714 // corresponding class template.
11715 if (!CurContext->getRedeclContext()->Equals(
11716 DC: GuidedTemplateDecl->getDeclContext()->getRedeclContext())) {
11717 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_deduction_guide_wrong_scope)
11718 << GuidedTemplateDecl;
11719 NoteTemplateLocation(Decl: *GuidedTemplateDecl);
11720 }
11721
11722 auto &DS = D.getMutableDeclSpec();
11723 // We leave 'friend' and 'virtual' to be rejected in the normal way.
11724 if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
11725 DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
11726 DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
11727 BadSpecifierDiagnoser Diagnoser(
11728 *this, D.getIdentifierLoc(),
11729 diag::err_deduction_guide_invalid_specifier);
11730
11731 Diagnoser.check(SpecLoc: DS.getStorageClassSpecLoc(), Spec: DS.getStorageClassSpec());
11732 DS.ClearStorageClassSpecs();
11733 SC = SC_None;
11734
11735 // 'explicit' is permitted.
11736 Diagnoser.check(SpecLoc: DS.getInlineSpecLoc(), Spec: "inline");
11737 Diagnoser.check(SpecLoc: DS.getNoreturnSpecLoc(), Spec: "_Noreturn");
11738 Diagnoser.check(SpecLoc: DS.getConstexprSpecLoc(), Spec: "constexpr");
11739 DS.ClearConstexprSpec();
11740
11741 Diagnoser.check(SpecLoc: DS.getConstSpecLoc(), Spec: "const");
11742 Diagnoser.check(SpecLoc: DS.getRestrictSpecLoc(), Spec: "__restrict");
11743 Diagnoser.check(SpecLoc: DS.getVolatileSpecLoc(), Spec: "volatile");
11744 Diagnoser.check(SpecLoc: DS.getAtomicSpecLoc(), Spec: "_Atomic");
11745 Diagnoser.check(SpecLoc: DS.getUnalignedSpecLoc(), Spec: "__unaligned");
11746 DS.ClearTypeQualifiers();
11747
11748 Diagnoser.check(SpecLoc: DS.getTypeSpecComplexLoc(), Spec: DS.getTypeSpecComplex());
11749 Diagnoser.check(SpecLoc: DS.getTypeSpecSignLoc(), Spec: DS.getTypeSpecSign());
11750 Diagnoser.check(SpecLoc: DS.getTypeSpecWidthLoc(), Spec: DS.getTypeSpecWidth());
11751 Diagnoser.check(SpecLoc: DS.getTypeSpecTypeLoc(), Spec: DS.getTypeSpecType());
11752 DS.ClearTypeSpecType();
11753 }
11754
11755 if (D.isInvalidType())
11756 return true;
11757
11758 // Check the declarator is simple enough.
11759 bool FoundFunction = false;
11760 for (const DeclaratorChunk &Chunk : llvm::reverse(C: D.type_objects())) {
11761 if (Chunk.Kind == DeclaratorChunk::Paren)
11762 continue;
11763 if (Chunk.Kind != DeclaratorChunk::Function || FoundFunction) {
11764 Diag(Loc: D.getDeclSpec().getBeginLoc(),
11765 DiagID: diag::err_deduction_guide_with_complex_decl)
11766 << D.getSourceRange();
11767 break;
11768 }
11769 if (!Chunk.Fun.hasTrailingReturnType())
11770 return Diag(Loc: D.getName().getBeginLoc(),
11771 DiagID: diag::err_deduction_guide_no_trailing_return_type);
11772
11773 // Check that the return type is written as a specialization of
11774 // the template specified as the deduction-guide's name.
11775 // The template name may not be qualified. [temp.deduct.guide]
11776 ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
11777 TypeSourceInfo *TSI = nullptr;
11778 QualType RetTy = GetTypeFromParser(Ty: TrailingReturnType, TInfo: &TSI);
11779 assert(TSI && "deduction guide has valid type but invalid return type?");
11780 bool AcceptableReturnType = false;
11781 bool MightInstantiateToSpecialization = false;
11782 if (auto RetTST =
11783 TSI->getTypeLoc().getAsAdjusted<TemplateSpecializationTypeLoc>()) {
11784 TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
11785 bool TemplateMatches = Context.hasSameTemplateName(
11786 X: SpecifiedName, Y: GuidedTemplate, /*IgnoreDeduced=*/true);
11787
11788 const QualifiedTemplateName *Qualifiers =
11789 SpecifiedName.getAsQualifiedTemplateName();
11790 assert(Qualifiers && "expected QualifiedTemplate");
11791 bool SimplyWritten =
11792 !Qualifiers->hasTemplateKeyword() && !Qualifiers->getQualifier();
11793 if (SimplyWritten && TemplateMatches)
11794 AcceptableReturnType = true;
11795 else {
11796 // This could still instantiate to the right type, unless we know it
11797 // names the wrong class template.
11798 auto *TD = SpecifiedName.getAsTemplateDecl();
11799 MightInstantiateToSpecialization =
11800 !(TD && isa<ClassTemplateDecl>(Val: TD) && !TemplateMatches);
11801 }
11802 } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
11803 MightInstantiateToSpecialization = true;
11804 }
11805
11806 if (!AcceptableReturnType)
11807 return Diag(Loc: TSI->getTypeLoc().getBeginLoc(),
11808 DiagID: diag::err_deduction_guide_bad_trailing_return_type)
11809 << GuidedTemplate << TSI->getType()
11810 << MightInstantiateToSpecialization
11811 << TSI->getTypeLoc().getSourceRange();
11812
11813 // Keep going to check that we don't have any inner declarator pieces (we
11814 // could still have a function returning a pointer to a function).
11815 FoundFunction = true;
11816 }
11817
11818 if (D.isFunctionDefinition())
11819 // we can still create a valid deduction guide here.
11820 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_deduction_guide_defines_function);
11821 return false;
11822}
11823
11824//===----------------------------------------------------------------------===//
11825// Namespace Handling
11826//===----------------------------------------------------------------------===//
11827
11828/// Diagnose a mismatch in 'inline' qualifiers when a namespace is
11829/// reopened.
11830static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc,
11831 SourceLocation Loc,
11832 IdentifierInfo *II, bool *IsInline,
11833 NamespaceDecl *PrevNS) {
11834 assert(*IsInline != PrevNS->isInline());
11835
11836 // 'inline' must appear on the original definition, but not necessarily
11837 // on all extension definitions, so the note should point to the first
11838 // definition to avoid confusion.
11839 PrevNS = PrevNS->getFirstDecl();
11840
11841 if (PrevNS->isInline())
11842 // The user probably just forgot the 'inline', so suggest that it
11843 // be added back.
11844 S.Diag(Loc, DiagID: diag::warn_inline_namespace_reopened_noninline)
11845 << FixItHint::CreateInsertion(InsertionLoc: KeywordLoc, Code: "inline ");
11846 else
11847 S.Diag(Loc, DiagID: diag::err_inline_namespace_mismatch);
11848
11849 S.Diag(Loc: PrevNS->getLocation(), DiagID: diag::note_previous_definition);
11850 *IsInline = PrevNS->isInline();
11851}
11852
11853/// ActOnStartNamespaceDef - This is called at the start of a namespace
11854/// definition.
11855Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
11856 SourceLocation InlineLoc,
11857 SourceLocation NamespaceLoc,
11858 SourceLocation IdentLoc, IdentifierInfo *II,
11859 SourceLocation LBrace,
11860 const ParsedAttributesView &AttrList,
11861 UsingDirectiveDecl *&UD, bool IsNested) {
11862 SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
11863 // For anonymous namespace, take the location of the left brace.
11864 SourceLocation Loc = II ? IdentLoc : LBrace;
11865 bool IsInline = InlineLoc.isValid();
11866 bool IsInvalid = false;
11867 bool IsStd = false;
11868 bool AddToKnown = false;
11869 Scope *DeclRegionScope = NamespcScope->getParent();
11870
11871 NamespaceDecl *PrevNS = nullptr;
11872 if (II) {
11873 // C++ [namespace.std]p7:
11874 // A translation unit shall not declare namespace std to be an inline
11875 // namespace (9.8.2).
11876 //
11877 // Precondition: the std namespace is in the file scope and is declared to
11878 // be inline
11879 auto DiagnoseInlineStdNS = [&]() {
11880 assert(IsInline && II->isStr("std") &&
11881 CurContext->getRedeclContext()->isTranslationUnit() &&
11882 "Precondition of DiagnoseInlineStdNS not met");
11883 Diag(Loc: InlineLoc, DiagID: diag::err_inline_namespace_std)
11884 << SourceRange(InlineLoc, InlineLoc.getLocWithOffset(Offset: 6));
11885 IsInline = false;
11886 };
11887 // C++ [namespace.def]p2:
11888 // The identifier in an original-namespace-definition shall not
11889 // have been previously defined in the declarative region in
11890 // which the original-namespace-definition appears. The
11891 // identifier in an original-namespace-definition is the name of
11892 // the namespace. Subsequently in that declarative region, it is
11893 // treated as an original-namespace-name.
11894 //
11895 // Since namespace names are unique in their scope, and we don't
11896 // look through using directives, just look for any ordinary names
11897 // as if by qualified name lookup.
11898 LookupResult R(*this, II, IdentLoc, LookupOrdinaryName,
11899 RedeclarationKind::ForExternalRedeclaration);
11900 LookupQualifiedName(R, LookupCtx: CurContext->getRedeclContext());
11901 NamedDecl *PrevDecl =
11902 R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
11903 PrevNS = dyn_cast_or_null<NamespaceDecl>(Val: PrevDecl);
11904
11905 if (PrevNS) {
11906 // This is an extended namespace definition.
11907 if (IsInline && II->isStr(Str: "std") &&
11908 CurContext->getRedeclContext()->isTranslationUnit())
11909 DiagnoseInlineStdNS();
11910 else if (IsInline != PrevNS->isInline())
11911 DiagnoseNamespaceInlineMismatch(S&: *this, KeywordLoc: NamespaceLoc, Loc, II,
11912 IsInline: &IsInline, PrevNS);
11913 } else if (PrevDecl) {
11914 // This is an invalid name redefinition.
11915 Diag(Loc, DiagID: diag::err_redefinition_different_kind)
11916 << II;
11917 Diag(Loc: PrevDecl->getLocation(), DiagID: diag::note_previous_definition);
11918 IsInvalid = true;
11919 // Continue on to push Namespc as current DeclContext and return it.
11920 } else if (II->isStr(Str: "std") &&
11921 CurContext->getRedeclContext()->isTranslationUnit()) {
11922 if (IsInline)
11923 DiagnoseInlineStdNS();
11924 // This is the first "real" definition of the namespace "std", so update
11925 // our cache of the "std" namespace to point at this definition.
11926 PrevNS = getStdNamespace();
11927 IsStd = true;
11928 AddToKnown = !IsInline;
11929 } else {
11930 // We've seen this namespace for the first time.
11931 AddToKnown = !IsInline;
11932 }
11933 } else {
11934 // Anonymous namespaces.
11935
11936 // Determine whether the parent already has an anonymous namespace.
11937 DeclContext *Parent = CurContext->getRedeclContext();
11938 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Val: Parent)) {
11939 PrevNS = TU->getAnonymousNamespace();
11940 } else {
11941 NamespaceDecl *ND = cast<NamespaceDecl>(Val: Parent);
11942 PrevNS = ND->getAnonymousNamespace();
11943 }
11944
11945 if (PrevNS && IsInline != PrevNS->isInline())
11946 DiagnoseNamespaceInlineMismatch(S&: *this, KeywordLoc: NamespaceLoc, Loc: NamespaceLoc, II,
11947 IsInline: &IsInline, PrevNS);
11948 }
11949
11950 NamespaceDecl *Namespc = NamespaceDecl::Create(
11951 C&: Context, DC: CurContext, Inline: IsInline, StartLoc, IdLoc: Loc, Id: II, PrevDecl: PrevNS, Nested: IsNested);
11952 if (IsInvalid)
11953 Namespc->setInvalidDecl();
11954
11955 ProcessDeclAttributeList(S: DeclRegionScope, D: Namespc, AttrList);
11956 AddPragmaAttributes(S: DeclRegionScope, D: Namespc);
11957 ProcessAPINotes(D: Namespc);
11958
11959 // FIXME: Should we be merging attributes?
11960 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
11961 PushNamespaceVisibilityAttr(Attr, Loc);
11962
11963 if (IsStd)
11964 StdNamespace = Namespc;
11965 if (AddToKnown)
11966 KnownNamespaces[Namespc] = false;
11967
11968 if (II) {
11969 PushOnScopeChains(D: Namespc, S: DeclRegionScope);
11970 } else {
11971 // Link the anonymous namespace into its parent.
11972 DeclContext *Parent = CurContext->getRedeclContext();
11973 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Val: Parent)) {
11974 TU->setAnonymousNamespace(Namespc);
11975 } else {
11976 cast<NamespaceDecl>(Val: Parent)->setAnonymousNamespace(Namespc);
11977 }
11978
11979 CurContext->addDecl(D: Namespc);
11980
11981 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
11982 // behaves as if it were replaced by
11983 // namespace unique { /* empty body */ }
11984 // using namespace unique;
11985 // namespace unique { namespace-body }
11986 // where all occurrences of 'unique' in a translation unit are
11987 // replaced by the same identifier and this identifier differs
11988 // from all other identifiers in the entire program.
11989
11990 // We just create the namespace with an empty name and then add an
11991 // implicit using declaration, just like the standard suggests.
11992 //
11993 // CodeGen enforces the "universally unique" aspect by giving all
11994 // declarations semantically contained within an anonymous
11995 // namespace internal linkage.
11996
11997 if (!PrevNS) {
11998 UD = UsingDirectiveDecl::Create(C&: Context, DC: Parent,
11999 /* 'using' */ UsingLoc: LBrace,
12000 /* 'namespace' */ NamespaceLoc: SourceLocation(),
12001 /* qualifier */ QualifierLoc: NestedNameSpecifierLoc(),
12002 /* identifier */ IdentLoc: SourceLocation(),
12003 Nominated: Namespc,
12004 /* Ancestor */ CommonAncestor: Parent);
12005 UD->setImplicit();
12006 Parent->addDecl(D: UD);
12007 }
12008 }
12009
12010 ActOnDocumentableDecl(D: Namespc);
12011
12012 // Although we could have an invalid decl (i.e. the namespace name is a
12013 // redefinition), push it as current DeclContext and try to continue parsing.
12014 // FIXME: We should be able to push Namespc here, so that the each DeclContext
12015 // for the namespace has the declarations that showed up in that particular
12016 // namespace definition.
12017 PushDeclContext(S: NamespcScope, DC: Namespc);
12018 return Namespc;
12019}
12020
12021/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
12022/// is a namespace alias, returns the namespace it points to.
12023static inline NamespaceDecl *getNamespaceDecl(NamespaceBaseDecl *D) {
12024 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(Val: D))
12025 return AD->getNamespace();
12026 return dyn_cast_or_null<NamespaceDecl>(Val: D);
12027}
12028
12029void Sema::ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) {
12030 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Val: Dcl);
12031 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
12032 Namespc->setRBraceLoc(RBrace);
12033 PopDeclContext();
12034 if (Namespc->hasAttr<VisibilityAttr>())
12035 PopPragmaVisibility(IsNamespaceEnd: true, EndLoc: RBrace);
12036 // If this namespace contains an export-declaration, export it now.
12037 if (DeferredExportedNamespaces.erase(Ptr: Namespc))
12038 Dcl->setModuleOwnershipKind(Decl::ModuleOwnershipKind::VisibleWhenImported);
12039}
12040
12041CXXRecordDecl *Sema::getStdBadAlloc() const {
12042 return cast_or_null<CXXRecordDecl>(
12043 Val: StdBadAlloc.get(Source: Context.getExternalSource()));
12044}
12045
12046EnumDecl *Sema::getStdAlignValT() const {
12047 return cast_or_null<EnumDecl>(Val: StdAlignValT.get(Source: Context.getExternalSource()));
12048}
12049
12050NamespaceDecl *Sema::getStdNamespace() const {
12051 return cast_or_null<NamespaceDecl>(
12052 Val: StdNamespace.get(Source: Context.getExternalSource()));
12053}
12054
12055namespace {
12056
12057enum UnsupportedSTLSelect {
12058 USS_InvalidMember,
12059 USS_MissingMember,
12060 USS_NonTrivial,
12061 USS_Other
12062};
12063
12064struct InvalidSTLDiagnoser {
12065 Sema &S;
12066 SourceLocation Loc;
12067 QualType TyForDiags;
12068
12069 QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name = "",
12070 const VarDecl *VD = nullptr) {
12071 {
12072 auto D = S.Diag(Loc, DiagID: diag::err_std_compare_type_not_supported)
12073 << TyForDiags << ((int)Sel);
12074 if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
12075 assert(!Name.empty());
12076 D << Name;
12077 }
12078 }
12079 if (Sel == USS_InvalidMember) {
12080 S.Diag(Loc: VD->getLocation(), DiagID: diag::note_var_declared_here)
12081 << VD << VD->getSourceRange();
12082 }
12083 return QualType();
12084 }
12085};
12086} // namespace
12087
12088QualType Sema::CheckComparisonCategoryType(ComparisonCategoryType Kind,
12089 SourceLocation Loc,
12090 ComparisonCategoryUsage Usage) {
12091 assert(getLangOpts().CPlusPlus &&
12092 "Looking for comparison category type outside of C++.");
12093
12094 // Use an elaborated type for diagnostics which has a name containing the
12095 // prepended 'std' namespace but not any inline namespace names.
12096 auto TyForDiags = [&](ComparisonCategoryInfo *Info) {
12097 NestedNameSpecifier Qualifier(Context, getStdNamespace(),
12098 /*Prefix=*/std::nullopt);
12099 return Context.getTagType(Keyword: ElaboratedTypeKeyword::None, Qualifier,
12100 TD: Info->Record,
12101 /*OwnsTag=*/false);
12102 };
12103
12104 // Check if we've already successfully checked the comparison category type
12105 // before. If so, skip checking it again.
12106 ComparisonCategoryInfo *Info = Context.CompCategories.lookupInfo(Kind);
12107 if (Info && FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)]) {
12108 // The only thing we need to check is that the type has a reachable
12109 // definition in the current context.
12110 if (RequireCompleteType(Loc, T: TyForDiags(Info), DiagID: diag::err_incomplete_type))
12111 return QualType();
12112
12113 return Info->getType();
12114 }
12115
12116 // If lookup failed
12117 if (!Info) {
12118 std::string NameForDiags = "std::";
12119 NameForDiags += ComparisonCategories::getCategoryString(Kind);
12120 Diag(Loc, DiagID: diag::err_implied_comparison_category_type_not_found)
12121 << NameForDiags << (int)Usage;
12122 return QualType();
12123 }
12124
12125 assert(Info->Kind == Kind);
12126 assert(Info->Record);
12127
12128 // Update the Record decl in case we encountered a forward declaration on our
12129 // first pass. FIXME: This is a bit of a hack.
12130 if (Info->Record->hasDefinition())
12131 Info->Record = Info->Record->getDefinition();
12132
12133 if (RequireCompleteType(Loc, T: TyForDiags(Info), DiagID: diag::err_incomplete_type))
12134 return QualType();
12135
12136 InvalidSTLDiagnoser UnsupportedSTLError{.S: *this, .Loc: Loc, .TyForDiags: TyForDiags(Info)};
12137
12138 if (!Info->Record->isTriviallyCopyable())
12139 return UnsupportedSTLError(USS_NonTrivial);
12140
12141 for (const CXXBaseSpecifier &BaseSpec : Info->Record->bases()) {
12142 CXXRecordDecl *Base = BaseSpec.getType()->getAsCXXRecordDecl();
12143 // Tolerate empty base classes.
12144 if (Base->isEmpty())
12145 continue;
12146 // Reject STL implementations which have at least one non-empty base.
12147 return UnsupportedSTLError();
12148 }
12149
12150 // Check that the STL has implemented the types using a single integer field.
12151 // This expectation allows better codegen for builtin operators. We require:
12152 // (1) The class has exactly one field.
12153 // (2) The field is an integral or enumeration type.
12154 auto FIt = Info->Record->field_begin(), FEnd = Info->Record->field_end();
12155 if (std::distance(first: FIt, last: FEnd) != 1 ||
12156 !FIt->getType()->isIntegralOrEnumerationType()) {
12157 return UnsupportedSTLError();
12158 }
12159
12160 // Build each of the require values and store them in Info.
12161 for (ComparisonCategoryResult CCR :
12162 ComparisonCategories::getPossibleResultsForType(Type: Kind)) {
12163 StringRef MemName = ComparisonCategories::getResultString(Kind: CCR);
12164 ComparisonCategoryInfo::ValueInfo *ValInfo = Info->lookupValueInfo(ValueKind: CCR);
12165
12166 if (!ValInfo)
12167 return UnsupportedSTLError(USS_MissingMember, MemName);
12168
12169 VarDecl *VD = ValInfo->VD;
12170 assert(VD && "should not be null!");
12171
12172 // Attempt to diagnose reasons why the STL definition of this type
12173 // might be foobar, including it failing to be a constant expression.
12174 // TODO Handle more ways the lookup or result can be invalid.
12175 if (!VD->isStaticDataMember() ||
12176 !VD->isUsableInConstantExpressions(C: Context))
12177 return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
12178
12179 // Attempt to evaluate the var decl as a constant expression and extract
12180 // the value of its first field as a ICE. If this fails, the STL
12181 // implementation is not supported.
12182 if (!ValInfo->hasValidIntValue())
12183 return UnsupportedSTLError();
12184
12185 MarkVariableReferenced(Loc, Var: VD);
12186 }
12187
12188 // We've successfully built the required types and expressions. Update
12189 // the cache and return the newly cached value.
12190 FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)] = true;
12191 return Info->getType();
12192}
12193
12194NamespaceDecl *Sema::getOrCreateStdNamespace() {
12195 if (!StdNamespace) {
12196 // The "std" namespace has not yet been defined, so build one implicitly.
12197 StdNamespace = NamespaceDecl::Create(
12198 C&: Context, DC: Context.getTranslationUnitDecl(),
12199 /*Inline=*/false, StartLoc: SourceLocation(), IdLoc: SourceLocation(),
12200 Id: &PP.getIdentifierTable().get(Name: "std"),
12201 /*PrevDecl=*/nullptr, /*Nested=*/false);
12202 getStdNamespace()->setImplicit(true);
12203 // We want the created NamespaceDecl to be available for redeclaration
12204 // lookups, but not for regular name lookups.
12205 Context.getTranslationUnitDecl()->addDecl(D: getStdNamespace());
12206 getStdNamespace()->clearIdentifierNamespace();
12207 }
12208
12209 return getStdNamespace();
12210}
12211
12212static bool isStdClassTemplate(Sema &S, QualType SugaredType, QualType *TypeArg,
12213 const char *ClassName,
12214 ClassTemplateDecl **CachedDecl,
12215 const Decl **MalformedDecl) {
12216 // We're looking for implicit instantiations of
12217 // template <typename U> class std::{ClassName}.
12218
12219 if (!S.StdNamespace) // If we haven't seen namespace std yet, this can't be
12220 // it.
12221 return false;
12222
12223 auto ReportMatchingNameAsMalformed = [&](NamedDecl *D) {
12224 if (!MalformedDecl)
12225 return;
12226 if (!D)
12227 D = SugaredType->getAsTagDecl();
12228 if (!D || !D->isInStdNamespace())
12229 return;
12230 IdentifierInfo *II = D->getDeclName().getAsIdentifierInfo();
12231 if (II && II == &S.PP.getIdentifierTable().get(Name: ClassName))
12232 *MalformedDecl = D;
12233 };
12234
12235 ClassTemplateDecl *Template = nullptr;
12236 ArrayRef<TemplateArgument> Arguments;
12237 if (const TemplateSpecializationType *TST =
12238 SugaredType->getAsNonAliasTemplateSpecializationType()) {
12239 Template = dyn_cast_or_null<ClassTemplateDecl>(
12240 Val: TST->getTemplateName().getAsTemplateDecl());
12241 Arguments = TST->template_arguments();
12242 } else if (const auto *TT = SugaredType->getAs<TagType>()) {
12243 Template = TT->getTemplateDecl();
12244 Arguments = TT->getTemplateArgs(Ctx: S.Context);
12245 }
12246
12247 if (!Template) {
12248 ReportMatchingNameAsMalformed(SugaredType->getAsTagDecl());
12249 return false;
12250 }
12251
12252 if (!*CachedDecl) {
12253 // Haven't recognized std::{ClassName} yet, maybe this is it.
12254 // FIXME: It seems we should just reuse LookupStdClassTemplate but the
12255 // semantics of this are slightly different, most notably the existing
12256 // "lookup" semantics explicitly diagnose an invalid definition as an
12257 // error.
12258 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
12259 if (TemplateClass->getIdentifier() !=
12260 &S.PP.getIdentifierTable().get(Name: ClassName) ||
12261 !S.getStdNamespace()->InEnclosingNamespaceSetOf(
12262 NS: TemplateClass->getNonTransparentDeclContext()))
12263 return false;
12264 // This is a template called std::{ClassName}, but is it the right
12265 // template?
12266 TemplateParameterList *Params = Template->getTemplateParameters();
12267 if (Params->getMinRequiredArguments() != 1 ||
12268 !isa<TemplateTypeParmDecl>(Val: Params->getParam(Idx: 0)) ||
12269 Params->getParam(Idx: 0)->isTemplateParameterPack()) {
12270 if (MalformedDecl)
12271 *MalformedDecl = TemplateClass;
12272 return false;
12273 }
12274
12275 // It's the right template.
12276 *CachedDecl = Template;
12277 }
12278
12279 if (Template->getCanonicalDecl() != (*CachedDecl)->getCanonicalDecl())
12280 return false;
12281
12282 // This is an instance of std::{ClassName}. Find the argument type.
12283 if (TypeArg) {
12284 QualType ArgType = Arguments[0].getAsType();
12285 // FIXME: Since TST only has as-written arguments, we have to perform the
12286 // only kind of conversion applicable to type arguments; in Objective-C ARC:
12287 // - If an explicitly-specified template argument type is a lifetime type
12288 // with no lifetime qualifier, the __strong lifetime qualifier is
12289 // inferred.
12290 if (S.getLangOpts().ObjCAutoRefCount && ArgType->isObjCLifetimeType() &&
12291 !ArgType.getObjCLifetime()) {
12292 Qualifiers Qs;
12293 Qs.setObjCLifetime(Qualifiers::OCL_Strong);
12294 ArgType = S.Context.getQualifiedType(T: ArgType, Qs);
12295 }
12296 *TypeArg = ArgType;
12297 }
12298
12299 return true;
12300}
12301
12302bool Sema::isStdInitializerList(QualType Ty, QualType *Element) {
12303 assert(getLangOpts().CPlusPlus &&
12304 "Looking for std::initializer_list outside of C++.");
12305
12306 // We're looking for implicit instantiations of
12307 // template <typename E> class std::initializer_list.
12308
12309 return isStdClassTemplate(S&: *this, SugaredType: Ty, TypeArg: Element, ClassName: "initializer_list",
12310 CachedDecl: &StdInitializerList, /*MalformedDecl=*/nullptr);
12311}
12312
12313bool Sema::isStdTypeIdentity(QualType Ty, QualType *Element,
12314 const Decl **MalformedDecl) {
12315 assert(getLangOpts().CPlusPlus &&
12316 "Looking for std::type_identity outside of C++.");
12317
12318 // We're looking for implicit instantiations of
12319 // template <typename T> struct std::type_identity.
12320
12321 return isStdClassTemplate(S&: *this, SugaredType: Ty, TypeArg: Element, ClassName: "type_identity",
12322 CachedDecl: &StdTypeIdentity, MalformedDecl);
12323}
12324
12325static ClassTemplateDecl *LookupStdClassTemplate(Sema &S, SourceLocation Loc,
12326 const char *ClassName,
12327 bool *WasMalformed) {
12328 if (!S.StdNamespace)
12329 return nullptr;
12330
12331 LookupResult Result(S, &S.PP.getIdentifierTable().get(Name: ClassName), Loc,
12332 Sema::LookupOrdinaryName);
12333 if (!S.LookupQualifiedName(R&: Result, LookupCtx: S.getStdNamespace()))
12334 return nullptr;
12335
12336 ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
12337 if (!Template) {
12338 Result.suppressDiagnostics();
12339 // We found something weird. Complain about the first thing we found.
12340 NamedDecl *Found = *Result.begin();
12341 S.Diag(Loc: Found->getLocation(), DiagID: diag::err_malformed_std_class_template)
12342 << ClassName;
12343 if (WasMalformed)
12344 *WasMalformed = true;
12345 return nullptr;
12346 }
12347
12348 // We found some template with the correct name. Now verify that it's
12349 // correct.
12350 TemplateParameterList *Params = Template->getTemplateParameters();
12351 if (Params->getMinRequiredArguments() != 1 ||
12352 !isa<TemplateTypeParmDecl>(Val: Params->getParam(Idx: 0))) {
12353 S.Diag(Loc: Template->getLocation(), DiagID: diag::err_malformed_std_class_template)
12354 << ClassName;
12355 if (WasMalformed)
12356 *WasMalformed = true;
12357 return nullptr;
12358 }
12359
12360 return Template;
12361}
12362
12363static QualType BuildStdClassTemplate(Sema &S, ClassTemplateDecl *CTD,
12364 QualType TypeParam, SourceLocation Loc) {
12365 assert(S.getStdNamespace());
12366 TemplateArgumentListInfo Args(Loc, Loc);
12367 auto TSI = S.Context.getTrivialTypeSourceInfo(T: TypeParam, Loc);
12368 Args.addArgument(Loc: TemplateArgumentLoc(TemplateArgument(TypeParam), TSI));
12369
12370 return S.CheckTemplateIdType(Keyword: ElaboratedTypeKeyword::None, Template: TemplateName(CTD),
12371 TemplateLoc: Loc, TemplateArgs&: Args, /*Scope=*/nullptr,
12372 /*ForNestedNameSpecifier=*/false);
12373}
12374
12375QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
12376 if (!StdInitializerList) {
12377 bool WasMalformed = false;
12378 StdInitializerList =
12379 LookupStdClassTemplate(S&: *this, Loc, ClassName: "initializer_list", WasMalformed: &WasMalformed);
12380 if (!StdInitializerList) {
12381 if (!WasMalformed)
12382 Diag(Loc, DiagID: diag::err_implied_std_initializer_list_not_found);
12383 return QualType();
12384 }
12385 }
12386 return BuildStdClassTemplate(S&: *this, CTD: StdInitializerList, TypeParam: Element, Loc);
12387}
12388
12389QualType Sema::tryBuildStdTypeIdentity(QualType Type, SourceLocation Loc) {
12390 if (!StdTypeIdentity) {
12391 StdTypeIdentity = LookupStdClassTemplate(S&: *this, Loc, ClassName: "type_identity",
12392 /*WasMalformed=*/nullptr);
12393 if (!StdTypeIdentity)
12394 return QualType();
12395 }
12396 return BuildStdClassTemplate(S&: *this, CTD: StdTypeIdentity, TypeParam: Type, Loc);
12397}
12398
12399bool Sema::isInitListConstructor(const FunctionDecl *Ctor) {
12400 // C++ [dcl.init.list]p2:
12401 // A constructor is an initializer-list constructor if its first parameter
12402 // is of type std::initializer_list<E> or reference to possibly cv-qualified
12403 // std::initializer_list<E> for some type E, and either there are no other
12404 // parameters or else all other parameters have default arguments.
12405 if (!Ctor->hasOneParamOrDefaultArgs())
12406 return false;
12407
12408 QualType ArgType = Ctor->getParamDecl(i: 0)->getType();
12409 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
12410 ArgType = RT->getPointeeType().getUnqualifiedType();
12411
12412 return isStdInitializerList(Ty: ArgType, Element: nullptr);
12413}
12414
12415/// Determine whether a using statement is in a context where it will be
12416/// apply in all contexts.
12417static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) {
12418 switch (CurContext->getDeclKind()) {
12419 case Decl::TranslationUnit:
12420 return true;
12421 case Decl::LinkageSpec:
12422 return IsUsingDirectiveInToplevelContext(CurContext: CurContext->getParent());
12423 default:
12424 return false;
12425 }
12426}
12427
12428namespace {
12429
12430// Callback to only accept typo corrections that are namespaces.
12431class NamespaceValidatorCCC final : public CorrectionCandidateCallback {
12432public:
12433 bool ValidateCandidate(const TypoCorrection &candidate) override {
12434 if (NamedDecl *ND = candidate.getCorrectionDecl())
12435 return isa<NamespaceDecl>(Val: ND) || isa<NamespaceAliasDecl>(Val: ND);
12436 return false;
12437 }
12438
12439 std::unique_ptr<CorrectionCandidateCallback> clone() override {
12440 return std::make_unique<NamespaceValidatorCCC>(args&: *this);
12441 }
12442};
12443
12444}
12445
12446static void DiagnoseInvisibleNamespace(const TypoCorrection &Corrected,
12447 Sema &S) {
12448 auto *ND = cast<NamespaceDecl>(Val: Corrected.getFoundDecl());
12449 Module *M = ND->getOwningModule();
12450 assert(M && "hidden namespace definition not in a module?");
12451
12452 if (M->isExplicitGlobalModule())
12453 S.Diag(Loc: Corrected.getCorrectionRange().getBegin(),
12454 DiagID: diag::err_module_unimported_use_header)
12455 << (int)Sema::MissingImportKind::Declaration << Corrected.getFoundDecl()
12456 << /*Header Name*/ false;
12457 else
12458 S.Diag(Loc: Corrected.getCorrectionRange().getBegin(),
12459 DiagID: diag::err_module_unimported_use)
12460 << (int)Sema::MissingImportKind::Declaration << Corrected.getFoundDecl()
12461 << M->getTopLevelModuleName();
12462}
12463
12464static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
12465 CXXScopeSpec &SS,
12466 SourceLocation IdentLoc,
12467 IdentifierInfo *Ident) {
12468 R.clear();
12469 NamespaceValidatorCCC CCC{};
12470 if (TypoCorrection Corrected =
12471 S.CorrectTypo(Typo: R.getLookupNameInfo(), LookupKind: R.getLookupKind(), S: Sc, SS: &SS, CCC,
12472 Mode: CorrectTypoKind::ErrorRecovery)) {
12473 // Generally we find it is confusing more than helpful to diagnose the
12474 // invisible namespace.
12475 // See https://github.com/llvm/llvm-project/issues/73893.
12476 //
12477 // However, we should diagnose when the users are trying to using an
12478 // invisible namespace. So we handle the case specially here.
12479 if (isa_and_nonnull<NamespaceDecl>(Val: Corrected.getFoundDecl()) &&
12480 Corrected.requiresImport()) {
12481 DiagnoseInvisibleNamespace(Corrected, S);
12482 } else if (DeclContext *DC = S.computeDeclContext(SS, EnteringContext: false)) {
12483 std::string CorrectedStr(Corrected.getAsString(LO: S.getLangOpts()));
12484 bool DroppedSpecifier =
12485 Corrected.WillReplaceSpecifier() && Ident->getName() == CorrectedStr;
12486 S.diagnoseTypo(Correction: Corrected,
12487 TypoDiag: S.PDiag(DiagID: diag::err_using_directive_member_suggest)
12488 << Ident << DC << DroppedSpecifier << SS.getRange(),
12489 PrevNote: S.PDiag(DiagID: diag::note_namespace_defined_here));
12490 } else {
12491 S.diagnoseTypo(Correction: Corrected,
12492 TypoDiag: S.PDiag(DiagID: diag::err_using_directive_suggest) << Ident,
12493 PrevNote: S.PDiag(DiagID: diag::note_namespace_defined_here));
12494 }
12495 R.addDecl(D: Corrected.getFoundDecl());
12496 return true;
12497 }
12498 return false;
12499}
12500
12501Decl *Sema::ActOnUsingDirective(Scope *S, SourceLocation UsingLoc,
12502 SourceLocation NamespcLoc, CXXScopeSpec &SS,
12503 SourceLocation IdentLoc,
12504 IdentifierInfo *NamespcName,
12505 const ParsedAttributesView &AttrList) {
12506 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
12507 assert(NamespcName && "Invalid NamespcName.");
12508 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
12509
12510 // Get the innermost enclosing declaration scope.
12511 S = S->getDeclParent();
12512
12513 UsingDirectiveDecl *UDir = nullptr;
12514 NestedNameSpecifier Qualifier = SS.getScopeRep();
12515
12516 // Lookup namespace name.
12517 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
12518 LookupParsedName(R, S, SS: &SS, /*ObjectType=*/QualType());
12519 if (R.isAmbiguous())
12520 return nullptr;
12521
12522 if (R.empty()) {
12523 R.clear();
12524 // Allow "using namespace std;" or "using namespace ::std;" even if
12525 // "std" hasn't been defined yet, for GCC compatibility.
12526 if ((!Qualifier ||
12527 Qualifier.getKind() == NestedNameSpecifier::Kind::Global) &&
12528 NamespcName->isStr(Str: "std")) {
12529 Diag(Loc: IdentLoc, DiagID: diag::ext_using_undefined_std);
12530 R.addDecl(D: getOrCreateStdNamespace());
12531 R.resolveKind();
12532 }
12533 // Otherwise, attempt typo correction.
12534 else
12535 TryNamespaceTypoCorrection(S&: *this, R, Sc: S, SS, IdentLoc, Ident: NamespcName);
12536 }
12537
12538 if (!R.empty()) {
12539 NamedDecl *Named = R.getRepresentativeDecl();
12540 NamespaceDecl *NS = R.getAsSingle<NamespaceDecl>();
12541 assert(NS && "expected namespace decl");
12542
12543 // The use of a nested name specifier may trigger deprecation warnings.
12544 DiagnoseUseOfDecl(D: Named, Locs: IdentLoc);
12545
12546 // C++ [namespace.udir]p1:
12547 // A using-directive specifies that the names in the nominated
12548 // namespace can be used in the scope in which the
12549 // using-directive appears after the using-directive. During
12550 // unqualified name lookup (3.4.1), the names appear as if they
12551 // were declared in the nearest enclosing namespace which
12552 // contains both the using-directive and the nominated
12553 // namespace. [Note: in this context, "contains" means "contains
12554 // directly or indirectly". ]
12555
12556 // Find enclosing context containing both using-directive and
12557 // nominated namespace.
12558 DeclContext *CommonAncestor = NS;
12559 while (CommonAncestor && !CommonAncestor->Encloses(DC: CurContext))
12560 CommonAncestor = CommonAncestor->getParent();
12561
12562 UDir = UsingDirectiveDecl::Create(C&: Context, DC: CurContext, UsingLoc, NamespaceLoc: NamespcLoc,
12563 QualifierLoc: SS.getWithLocInContext(Context),
12564 IdentLoc, Nominated: Named, CommonAncestor);
12565
12566 if (IsUsingDirectiveInToplevelContext(CurContext) &&
12567 !SourceMgr.isInMainFile(Loc: SourceMgr.getExpansionLoc(Loc: IdentLoc))) {
12568 Diag(Loc: IdentLoc, DiagID: diag::warn_using_directive_in_header);
12569 }
12570
12571 PushUsingDirective(S, UDir);
12572 } else {
12573 Diag(Loc: IdentLoc, DiagID: diag::err_expected_namespace_name) << SS.getRange();
12574 }
12575
12576 if (UDir) {
12577 ProcessDeclAttributeList(S, D: UDir, AttrList);
12578 ProcessAPINotes(D: UDir);
12579 }
12580
12581 return UDir;
12582}
12583
12584void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
12585 // If the scope has an associated entity and the using directive is at
12586 // namespace or translation unit scope, add the UsingDirectiveDecl into
12587 // its lookup structure so qualified name lookup can find it.
12588 DeclContext *Ctx = S->getEntity();
12589 if (Ctx && !Ctx->isFunctionOrMethod())
12590 Ctx->addDecl(D: UDir);
12591 else
12592 // Otherwise, it is at block scope. The using-directives will affect lookup
12593 // only to the end of the scope.
12594 S->PushUsingDirective(UDir);
12595}
12596
12597Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS,
12598 SourceLocation UsingLoc,
12599 SourceLocation TypenameLoc, CXXScopeSpec &SS,
12600 UnqualifiedId &Name,
12601 SourceLocation EllipsisLoc,
12602 const ParsedAttributesView &AttrList) {
12603 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
12604
12605 if (SS.isEmpty()) {
12606 Diag(Loc: Name.getBeginLoc(), DiagID: diag::err_using_requires_qualname);
12607 return nullptr;
12608 }
12609
12610 switch (Name.getKind()) {
12611 case UnqualifiedIdKind::IK_ImplicitSelfParam:
12612 case UnqualifiedIdKind::IK_Identifier:
12613 case UnqualifiedIdKind::IK_OperatorFunctionId:
12614 case UnqualifiedIdKind::IK_LiteralOperatorId:
12615 case UnqualifiedIdKind::IK_ConversionFunctionId:
12616 break;
12617
12618 case UnqualifiedIdKind::IK_ConstructorName:
12619 case UnqualifiedIdKind::IK_ConstructorTemplateId:
12620 // C++11 inheriting constructors.
12621 Diag(Loc: Name.getBeginLoc(),
12622 DiagID: getLangOpts().CPlusPlus11
12623 ? diag::warn_cxx98_compat_using_decl_constructor
12624 : diag::err_using_decl_constructor)
12625 << SS.getRange();
12626
12627 if (getLangOpts().CPlusPlus11) break;
12628
12629 return nullptr;
12630
12631 case UnqualifiedIdKind::IK_DestructorName:
12632 Diag(Loc: Name.getBeginLoc(), DiagID: diag::err_using_decl_destructor) << SS.getRange();
12633 return nullptr;
12634
12635 case UnqualifiedIdKind::IK_TemplateId:
12636 Diag(Loc: Name.getBeginLoc(), DiagID: diag::err_using_decl_template_id)
12637 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
12638 return nullptr;
12639
12640 case UnqualifiedIdKind::IK_DeductionGuideName:
12641 llvm_unreachable("cannot parse qualified deduction guide name");
12642 }
12643
12644 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
12645 DeclarationName TargetName = TargetNameInfo.getName();
12646 if (!TargetName)
12647 return nullptr;
12648
12649 // Warn about access declarations.
12650 if (UsingLoc.isInvalid()) {
12651 Diag(Loc: Name.getBeginLoc(), DiagID: getLangOpts().CPlusPlus11
12652 ? diag::err_access_decl
12653 : diag::warn_access_decl_deprecated)
12654 << FixItHint::CreateInsertion(InsertionLoc: SS.getRange().getBegin(), Code: "using ");
12655 }
12656
12657 if (EllipsisLoc.isInvalid()) {
12658 if (DiagnoseUnexpandedParameterPack(SS, UPPC: UPPC_UsingDeclaration) ||
12659 DiagnoseUnexpandedParameterPack(NameInfo: TargetNameInfo, UPPC: UPPC_UsingDeclaration))
12660 return nullptr;
12661 } else {
12662 if (!SS.getScopeRep().containsUnexpandedParameterPack() &&
12663 !TargetNameInfo.containsUnexpandedParameterPack()) {
12664 Diag(Loc: EllipsisLoc, DiagID: diag::err_pack_expansion_without_parameter_packs)
12665 << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
12666 EllipsisLoc = SourceLocation();
12667 }
12668 }
12669
12670 NamedDecl *UD =
12671 BuildUsingDeclaration(S, AS, UsingLoc, HasTypenameKeyword: TypenameLoc.isValid(), TypenameLoc,
12672 SS, NameInfo: TargetNameInfo, EllipsisLoc, AttrList,
12673 /*IsInstantiation*/ false,
12674 IsUsingIfExists: AttrList.hasAttribute(K: ParsedAttr::AT_UsingIfExists));
12675 if (UD)
12676 PushOnScopeChains(D: UD, S, /*AddToContext*/ false);
12677
12678 return UD;
12679}
12680
12681Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
12682 SourceLocation UsingLoc,
12683 SourceLocation EnumLoc, SourceRange TyLoc,
12684 const IdentifierInfo &II, ParsedType Ty,
12685 const CXXScopeSpec &SS) {
12686 TypeSourceInfo *TSI = nullptr;
12687 SourceLocation IdentLoc = TyLoc.getBegin();
12688 QualType EnumTy = GetTypeFromParser(Ty, TInfo: &TSI);
12689 if (EnumTy.isNull()) {
12690 Diag(Loc: IdentLoc, DiagID: isDependentScopeSpecifier(SS)
12691 ? diag::err_using_enum_is_dependent
12692 : diag::err_unknown_typename)
12693 << II.getName()
12694 << SourceRange(SS.isValid() ? SS.getBeginLoc() : IdentLoc,
12695 TyLoc.getEnd());
12696 return nullptr;
12697 }
12698
12699 if (EnumTy->isDependentType()) {
12700 Diag(Loc: IdentLoc, DiagID: diag::err_using_enum_is_dependent);
12701 return nullptr;
12702 }
12703
12704 auto *Enum = EnumTy->getAsEnumDecl();
12705 if (!Enum) {
12706 Diag(Loc: IdentLoc, DiagID: diag::err_using_enum_not_enum) << EnumTy;
12707 return nullptr;
12708 }
12709
12710 if (TSI == nullptr)
12711 TSI = Context.getTrivialTypeSourceInfo(T: EnumTy, Loc: IdentLoc);
12712
12713 auto *UD =
12714 BuildUsingEnumDeclaration(S, AS, UsingLoc, EnumLoc, NameLoc: IdentLoc, EnumType: TSI, ED: Enum);
12715
12716 if (UD)
12717 PushOnScopeChains(D: UD, S, /*AddToContext*/ false);
12718
12719 return UD;
12720}
12721
12722/// Determine whether a using declaration considers the given
12723/// declarations as "equivalent", e.g., if they are redeclarations of
12724/// the same entity or are both typedefs of the same type.
12725static bool
12726IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2) {
12727 if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
12728 return true;
12729
12730 if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(Val: D1))
12731 if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(Val: D2))
12732 return Context.hasSameType(T1: TD1->getUnderlyingType(),
12733 T2: TD2->getUnderlyingType());
12734
12735 // Two using_if_exists using-declarations are equivalent if both are
12736 // unresolved.
12737 if (isa<UnresolvedUsingIfExistsDecl>(Val: D1) &&
12738 isa<UnresolvedUsingIfExistsDecl>(Val: D2))
12739 return true;
12740
12741 return false;
12742}
12743
12744bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig,
12745 const LookupResult &Previous,
12746 UsingShadowDecl *&PrevShadow) {
12747 // Diagnose finding a decl which is not from a base class of the
12748 // current class. We do this now because there are cases where this
12749 // function will silently decide not to build a shadow decl, which
12750 // will pre-empt further diagnostics.
12751 //
12752 // We don't need to do this in C++11 because we do the check once on
12753 // the qualifier.
12754 //
12755 // FIXME: diagnose the following if we care enough:
12756 // struct A { int foo; };
12757 // struct B : A { using A::foo; };
12758 // template <class T> struct C : A {};
12759 // template <class T> struct D : C<T> { using B::foo; } // <---
12760 // This is invalid (during instantiation) in C++03 because B::foo
12761 // resolves to the using decl in B, which is not a base class of D<T>.
12762 // We can't diagnose it immediately because C<T> is an unknown
12763 // specialization. The UsingShadowDecl in D<T> then points directly
12764 // to A::foo, which will look well-formed when we instantiate.
12765 // The right solution is to not collapse the shadow-decl chain.
12766 if (!getLangOpts().CPlusPlus11 && CurContext->isRecord())
12767 if (auto *Using = dyn_cast<UsingDecl>(Val: BUD)) {
12768 DeclContext *OrigDC = Orig->getDeclContext();
12769
12770 // Handle enums and anonymous structs.
12771 if (isa<EnumDecl>(Val: OrigDC))
12772 OrigDC = OrigDC->getParent();
12773 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(Val: OrigDC);
12774 while (OrigRec->isAnonymousStructOrUnion())
12775 OrigRec = cast<CXXRecordDecl>(Val: OrigRec->getDeclContext());
12776
12777 if (cast<CXXRecordDecl>(Val: CurContext)->isProvablyNotDerivedFrom(Base: OrigRec)) {
12778 if (OrigDC == CurContext) {
12779 Diag(Loc: Using->getLocation(),
12780 DiagID: diag::err_using_decl_nested_name_specifier_is_current_class)
12781 << Using->getQualifierLoc().getSourceRange();
12782 Diag(Loc: Orig->getLocation(), DiagID: diag::note_using_decl_target);
12783 Using->setInvalidDecl();
12784 return true;
12785 }
12786
12787 Diag(Loc: Using->getQualifierLoc().getBeginLoc(),
12788 DiagID: diag::err_using_decl_nested_name_specifier_is_not_base_class)
12789 << Using->getQualifier() << cast<CXXRecordDecl>(Val: CurContext)
12790 << Using->getQualifierLoc().getSourceRange();
12791 Diag(Loc: Orig->getLocation(), DiagID: diag::note_using_decl_target);
12792 Using->setInvalidDecl();
12793 return true;
12794 }
12795 }
12796
12797 if (Previous.empty()) return false;
12798
12799 NamedDecl *Target = Orig;
12800 if (isa<UsingShadowDecl>(Val: Target))
12801 Target = cast<UsingShadowDecl>(Val: Target)->getTargetDecl();
12802
12803 // If the target happens to be one of the previous declarations, we
12804 // don't have a conflict.
12805 //
12806 // FIXME: but we might be increasing its access, in which case we
12807 // should redeclare it.
12808 NamedDecl *NonTag = nullptr, *Tag = nullptr;
12809 bool FoundEquivalentDecl = false;
12810 for (NamedDecl *Element : Previous) {
12811 NamedDecl *D = Element->getUnderlyingDecl();
12812 // We can have UsingDecls in our Previous results because we use the same
12813 // LookupResult for checking whether the UsingDecl itself is a valid
12814 // redeclaration.
12815 if (isa<UsingDecl>(Val: D) || isa<UsingPackDecl>(Val: D) || isa<UsingEnumDecl>(Val: D))
12816 continue;
12817
12818 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: D)) {
12819 // C++ [class.mem]p19:
12820 // If T is the name of a class, then [every named member other than
12821 // a non-static data member] shall have a name different from T
12822 if (RD->isInjectedClassName() && !isa<FieldDecl>(Val: Target) &&
12823 !isa<IndirectFieldDecl>(Val: Target) &&
12824 !isa<UnresolvedUsingValueDecl>(Val: Target) &&
12825 DiagnoseClassNameShadow(
12826 DC: CurContext,
12827 Info: DeclarationNameInfo(BUD->getDeclName(), BUD->getLocation())))
12828 return true;
12829 }
12830
12831 if (IsEquivalentForUsingDecl(Context, D1: D, D2: Target)) {
12832 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(Val: Element))
12833 PrevShadow = Shadow;
12834 FoundEquivalentDecl = true;
12835 } else if (isEquivalentInternalLinkageDeclaration(A: D, B: Target)) {
12836 // We don't conflict with an existing using shadow decl of an equivalent
12837 // declaration, but we're not a redeclaration of it.
12838 FoundEquivalentDecl = true;
12839 }
12840
12841 if (isVisible(D))
12842 (isa<TagDecl>(Val: D) ? Tag : NonTag) = D;
12843 }
12844
12845 if (FoundEquivalentDecl)
12846 return false;
12847
12848 // Always emit a diagnostic for a mismatch between an unresolved
12849 // using_if_exists and a resolved using declaration in either direction.
12850 if (isa<UnresolvedUsingIfExistsDecl>(Val: Target) !=
12851 (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(Val: NonTag))) {
12852 if (!NonTag && !Tag)
12853 return false;
12854 Diag(Loc: BUD->getLocation(), DiagID: diag::err_using_decl_conflict);
12855 Diag(Loc: Target->getLocation(), DiagID: diag::note_using_decl_target);
12856 Diag(Loc: (NonTag ? NonTag : Tag)->getLocation(),
12857 DiagID: diag::note_using_decl_conflict);
12858 BUD->setInvalidDecl();
12859 return true;
12860 }
12861
12862 if (FunctionDecl *FD = Target->getAsFunction()) {
12863 NamedDecl *OldDecl = nullptr;
12864 switch (CheckOverload(S: nullptr, New: FD, OldDecls: Previous, OldDecl,
12865 /*IsForUsingDecl*/ UseMemberUsingDeclRules: true)) {
12866 case OverloadKind::Overload:
12867 return false;
12868
12869 case OverloadKind::NonFunction:
12870 Diag(Loc: BUD->getLocation(), DiagID: diag::err_using_decl_conflict);
12871 break;
12872
12873 // We found a decl with the exact signature.
12874 case OverloadKind::Match:
12875 // If we're in a record, we want to hide the target, so we
12876 // return true (without a diagnostic) to tell the caller not to
12877 // build a shadow decl.
12878 if (CurContext->isRecord())
12879 return true;
12880
12881 // If we're not in a record, this is an error.
12882 Diag(Loc: BUD->getLocation(), DiagID: diag::err_using_decl_conflict);
12883 break;
12884 }
12885
12886 Diag(Loc: Target->getLocation(), DiagID: diag::note_using_decl_target);
12887 Diag(Loc: OldDecl->getLocation(), DiagID: diag::note_using_decl_conflict);
12888 BUD->setInvalidDecl();
12889 return true;
12890 }
12891
12892 // Target is not a function.
12893
12894 if (isa<TagDecl>(Val: Target)) {
12895 // No conflict between a tag and a non-tag.
12896 if (!Tag) return false;
12897
12898 Diag(Loc: BUD->getLocation(), DiagID: diag::err_using_decl_conflict);
12899 Diag(Loc: Target->getLocation(), DiagID: diag::note_using_decl_target);
12900 Diag(Loc: Tag->getLocation(), DiagID: diag::note_using_decl_conflict);
12901 BUD->setInvalidDecl();
12902 return true;
12903 }
12904
12905 // No conflict between a tag and a non-tag.
12906 if (!NonTag) return false;
12907
12908 Diag(Loc: BUD->getLocation(), DiagID: diag::err_using_decl_conflict);
12909 Diag(Loc: Target->getLocation(), DiagID: diag::note_using_decl_target);
12910 Diag(Loc: NonTag->getLocation(), DiagID: diag::note_using_decl_conflict);
12911 BUD->setInvalidDecl();
12912 return true;
12913}
12914
12915/// Determine whether a direct base class is a virtual base class.
12916static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
12917 if (!Derived->getNumVBases())
12918 return false;
12919 for (auto &B : Derived->bases())
12920 if (B.getType()->getAsCXXRecordDecl() == Base)
12921 return B.isVirtual();
12922 llvm_unreachable("not a direct base class");
12923}
12924
12925UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD,
12926 NamedDecl *Orig,
12927 UsingShadowDecl *PrevDecl) {
12928 // If we resolved to another shadow declaration, just coalesce them.
12929 NamedDecl *Target = Orig;
12930 if (isa<UsingShadowDecl>(Val: Target)) {
12931 Target = cast<UsingShadowDecl>(Val: Target)->getTargetDecl();
12932 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
12933 }
12934
12935 NamedDecl *NonTemplateTarget = Target;
12936 if (auto *TargetTD = dyn_cast<TemplateDecl>(Val: Target))
12937 NonTemplateTarget = TargetTD->getTemplatedDecl();
12938
12939 UsingShadowDecl *Shadow;
12940 if (NonTemplateTarget && isa<CXXConstructorDecl>(Val: NonTemplateTarget)) {
12941 UsingDecl *Using = cast<UsingDecl>(Val: BUD);
12942 bool IsVirtualBase =
12943 isVirtualDirectBase(Derived: cast<CXXRecordDecl>(Val: CurContext),
12944 Base: Using->getQualifier().getAsRecordDecl());
12945 Shadow = ConstructorUsingShadowDecl::Create(
12946 C&: Context, DC: CurContext, Loc: Using->getLocation(), Using, Target: Orig, IsVirtual: IsVirtualBase);
12947 } else {
12948 Shadow = UsingShadowDecl::Create(C&: Context, DC: CurContext, Loc: BUD->getLocation(),
12949 Name: Target->getDeclName(), Introducer: BUD, Target);
12950 }
12951 BUD->addShadowDecl(S: Shadow);
12952
12953 Shadow->setAccess(BUD->getAccess());
12954 if (Orig->isInvalidDecl() || BUD->isInvalidDecl())
12955 Shadow->setInvalidDecl();
12956
12957 Shadow->setPreviousDecl(PrevDecl);
12958
12959 if (S)
12960 PushOnScopeChains(D: Shadow, S);
12961 else
12962 CurContext->addDecl(D: Shadow);
12963
12964
12965 return Shadow;
12966}
12967
12968void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
12969 if (Shadow->getDeclName().getNameKind() ==
12970 DeclarationName::CXXConversionFunctionName)
12971 cast<CXXRecordDecl>(Val: Shadow->getDeclContext())->removeConversion(Old: Shadow);
12972
12973 // Remove it from the DeclContext...
12974 Shadow->getDeclContext()->removeDecl(D: Shadow);
12975
12976 // ...and the scope, if applicable...
12977 if (S) {
12978 S->RemoveDecl(D: Shadow);
12979 IdResolver.RemoveDecl(D: Shadow);
12980 }
12981
12982 // ...and the using decl.
12983 Shadow->getIntroducer()->removeShadowDecl(S: Shadow);
12984
12985 // TODO: complain somehow if Shadow was used. It shouldn't
12986 // be possible for this to happen, because...?
12987}
12988
12989/// Find the base specifier for a base class with the given type.
12990static CXXBaseSpecifier *findDirectBaseWithType(CXXRecordDecl *Derived,
12991 QualType DesiredBase,
12992 bool &AnyDependentBases) {
12993 // Check whether the named type is a direct base class.
12994 CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
12995 for (auto &Base : Derived->bases()) {
12996 CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
12997 if (CanonicalDesiredBase == BaseType)
12998 return &Base;
12999 if (BaseType->isDependentType())
13000 AnyDependentBases = true;
13001 }
13002 return nullptr;
13003}
13004
13005namespace {
13006class UsingValidatorCCC final : public CorrectionCandidateCallback {
13007public:
13008 UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
13009 NestedNameSpecifier NNS, CXXRecordDecl *RequireMemberOf)
13010 : HasTypenameKeyword(HasTypenameKeyword),
13011 IsInstantiation(IsInstantiation), OldNNS(NNS),
13012 RequireMemberOf(RequireMemberOf) {}
13013
13014 bool ValidateCandidate(const TypoCorrection &Candidate) override {
13015 NamedDecl *ND = Candidate.getCorrectionDecl();
13016
13017 // Keywords are not valid here.
13018 if (!ND || isa<NamespaceDecl>(Val: ND))
13019 return false;
13020
13021 // Completely unqualified names are invalid for a 'using' declaration.
13022 if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
13023 return false;
13024
13025 // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
13026 // reject.
13027
13028 if (RequireMemberOf) {
13029 auto *FoundRecord = dyn_cast<CXXRecordDecl>(Val: ND);
13030 if (FoundRecord && FoundRecord->isInjectedClassName()) {
13031 // No-one ever wants a using-declaration to name an injected-class-name
13032 // of a base class, unless they're declaring an inheriting constructor.
13033 ASTContext &Ctx = ND->getASTContext();
13034 if (!Ctx.getLangOpts().CPlusPlus11)
13035 return false;
13036 CanQualType FoundType = Ctx.getCanonicalTagType(TD: FoundRecord);
13037
13038 // Check that the injected-class-name is named as a member of its own
13039 // type; we don't want to suggest 'using Derived::Base;', since that
13040 // means something else.
13041 NestedNameSpecifier Specifier = Candidate.WillReplaceSpecifier()
13042 ? Candidate.getCorrectionSpecifier()
13043 : OldNNS;
13044 if (Specifier.getKind() != NestedNameSpecifier::Kind::Type ||
13045 !Ctx.hasSameType(T1: QualType(Specifier.getAsType(), 0), T2: FoundType))
13046 return false;
13047
13048 // Check that this inheriting constructor declaration actually names a
13049 // direct base class of the current class.
13050 bool AnyDependentBases = false;
13051 if (!findDirectBaseWithType(Derived: RequireMemberOf,
13052 DesiredBase: Ctx.getCanonicalTagType(TD: FoundRecord),
13053 AnyDependentBases) &&
13054 !AnyDependentBases)
13055 return false;
13056 } else {
13057 auto *RD = dyn_cast<CXXRecordDecl>(Val: ND->getDeclContext());
13058 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(Base: RD))
13059 return false;
13060
13061 // FIXME: Check that the base class member is accessible?
13062 }
13063 } else {
13064 auto *FoundRecord = dyn_cast<CXXRecordDecl>(Val: ND);
13065 if (FoundRecord && FoundRecord->isInjectedClassName())
13066 return false;
13067 }
13068
13069 if (isa<TypeDecl>(Val: ND))
13070 return HasTypenameKeyword || !IsInstantiation;
13071
13072 return !HasTypenameKeyword;
13073 }
13074
13075 std::unique_ptr<CorrectionCandidateCallback> clone() override {
13076 return std::make_unique<UsingValidatorCCC>(args&: *this);
13077 }
13078
13079private:
13080 bool HasTypenameKeyword;
13081 bool IsInstantiation;
13082 NestedNameSpecifier OldNNS;
13083 CXXRecordDecl *RequireMemberOf;
13084};
13085} // end anonymous namespace
13086
13087void Sema::FilterUsingLookup(Scope *S, LookupResult &Previous) {
13088 // It is really dumb that we have to do this.
13089 LookupResult::Filter F = Previous.makeFilter();
13090 while (F.hasNext()) {
13091 NamedDecl *D = F.next();
13092 if (!isDeclInScope(D, Ctx: CurContext, S))
13093 F.erase();
13094 // If we found a local extern declaration that's not ordinarily visible,
13095 // and this declaration is being added to a non-block scope, ignore it.
13096 // We're only checking for scope conflicts here, not also for violations
13097 // of the linkage rules.
13098 else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
13099 !(D->getIdentifierNamespace() & Decl::IDNS_Ordinary))
13100 F.erase();
13101 }
13102 F.done();
13103}
13104
13105NamedDecl *Sema::BuildUsingDeclaration(
13106 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
13107 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
13108 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
13109 const ParsedAttributesView &AttrList, bool IsInstantiation,
13110 bool IsUsingIfExists) {
13111 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
13112 SourceLocation IdentLoc = NameInfo.getLoc();
13113 assert(IdentLoc.isValid() && "Invalid TargetName location.");
13114
13115 // FIXME: We ignore attributes for now.
13116
13117 // For an inheriting constructor declaration, the name of the using
13118 // declaration is the name of a constructor in this class, not in the
13119 // base class.
13120 DeclarationNameInfo UsingName = NameInfo;
13121 if (UsingName.getName().getNameKind() == DeclarationName::CXXConstructorName)
13122 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: CurContext))
13123 UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
13124 Ty: Context.getCanonicalTagType(TD: RD)));
13125
13126 // Do the redeclaration lookup in the current scope.
13127 LookupResult Previous(*this, UsingName, LookupUsingDeclName,
13128 RedeclarationKind::ForVisibleRedeclaration);
13129 Previous.setHideTags(false);
13130 if (S) {
13131 LookupName(R&: Previous, S);
13132
13133 FilterUsingLookup(S, Previous);
13134 } else {
13135 assert(IsInstantiation && "no scope in non-instantiation");
13136 if (CurContext->isRecord())
13137 LookupQualifiedName(R&: Previous, LookupCtx: CurContext);
13138 else {
13139 // No redeclaration check is needed here; in non-member contexts we
13140 // diagnosed all possible conflicts with other using-declarations when
13141 // building the template:
13142 //
13143 // For a dependent non-type using declaration, the only valid case is
13144 // if we instantiate to a single enumerator. We check for conflicts
13145 // between shadow declarations we introduce, and we check in the template
13146 // definition for conflicts between a non-type using declaration and any
13147 // other declaration, which together covers all cases.
13148 //
13149 // A dependent typename using declaration will never successfully
13150 // instantiate, since it will always name a class member, so we reject
13151 // that in the template definition.
13152 }
13153 }
13154
13155 // Check for invalid redeclarations.
13156 if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
13157 SS, NameLoc: IdentLoc, Previous))
13158 return nullptr;
13159
13160 // 'using_if_exists' doesn't make sense on an inherited constructor.
13161 if (IsUsingIfExists && UsingName.getName().getNameKind() ==
13162 DeclarationName::CXXConstructorName) {
13163 Diag(Loc: UsingLoc, DiagID: diag::err_using_if_exists_on_ctor);
13164 return nullptr;
13165 }
13166
13167 DeclContext *LookupContext = computeDeclContext(SS);
13168 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
13169 if (!LookupContext || EllipsisLoc.isValid()) {
13170 NamedDecl *D;
13171 // Dependent scope, or an unexpanded pack
13172 if (!LookupContext && CheckUsingDeclQualifier(UsingLoc, HasTypename: HasTypenameKeyword,
13173 SS, NameInfo, NameLoc: IdentLoc))
13174 return nullptr;
13175
13176 if (Previous.isSingleResult() &&
13177 Previous.getFoundDecl()->isTemplateParameter())
13178 DiagnoseTemplateParameterShadow(Loc: IdentLoc, PrevDecl: Previous.getFoundDecl());
13179
13180 if (HasTypenameKeyword) {
13181 // FIXME: not all declaration name kinds are legal here
13182 D = UnresolvedUsingTypenameDecl::Create(C&: Context, DC: CurContext,
13183 UsingLoc, TypenameLoc,
13184 QualifierLoc,
13185 TargetNameLoc: IdentLoc, TargetName: NameInfo.getName(),
13186 EllipsisLoc);
13187 } else {
13188 D = UnresolvedUsingValueDecl::Create(C&: Context, DC: CurContext, UsingLoc,
13189 QualifierLoc, NameInfo, EllipsisLoc);
13190 }
13191 D->setAccess(AS);
13192 CurContext->addDecl(D);
13193 ProcessDeclAttributeList(S, D, AttrList);
13194 return D;
13195 }
13196
13197 auto Build = [&](bool Invalid) {
13198 UsingDecl *UD =
13199 UsingDecl::Create(C&: Context, DC: CurContext, UsingL: UsingLoc, QualifierLoc,
13200 NameInfo: UsingName, HasTypenameKeyword);
13201 UD->setAccess(AS);
13202 CurContext->addDecl(D: UD);
13203 ProcessDeclAttributeList(S, D: UD, AttrList);
13204 UD->setInvalidDecl(Invalid);
13205 return UD;
13206 };
13207 auto BuildInvalid = [&]{ return Build(true); };
13208 auto BuildValid = [&]{ return Build(false); };
13209
13210 if (RequireCompleteDeclContext(SS, DC: LookupContext))
13211 return BuildInvalid();
13212
13213 // Look up the target name.
13214 LookupResult R(*this, NameInfo, LookupOrdinaryName);
13215
13216 // Unlike most lookups, we don't always want to hide tag
13217 // declarations: tag names are visible through the using declaration
13218 // even if hidden by ordinary names, *except* in a dependent context
13219 // where they may be used by two-phase lookup.
13220 if (!IsInstantiation)
13221 R.setHideTags(false);
13222
13223 // For the purposes of this lookup, we have a base object type
13224 // equal to that of the current context.
13225 if (CurContext->isRecord()) {
13226 R.setBaseObjectType(
13227 Context.getCanonicalTagType(TD: cast<CXXRecordDecl>(Val: CurContext)));
13228 }
13229
13230 LookupQualifiedName(R, LookupCtx: LookupContext);
13231
13232 // Validate the context, now we have a lookup
13233 if (CheckUsingDeclQualifier(UsingLoc, HasTypename: HasTypenameKeyword, SS, NameInfo,
13234 NameLoc: IdentLoc, R: &R))
13235 return nullptr;
13236
13237 if (R.empty() && IsUsingIfExists)
13238 R.addDecl(D: UnresolvedUsingIfExistsDecl::Create(Ctx&: Context, DC: CurContext, Loc: UsingLoc,
13239 Name: UsingName.getName()),
13240 AS: AS_public);
13241
13242 // Try to correct typos if possible. If constructor name lookup finds no
13243 // results, that means the named class has no explicit constructors, and we
13244 // suppressed declaring implicit ones (probably because it's dependent or
13245 // invalid).
13246 if (R.empty() &&
13247 NameInfo.getName().getNameKind() != DeclarationName::CXXConstructorName) {
13248 // HACK 2017-01-08: Work around an issue with libstdc++'s detection of
13249 // ::gets. Sometimes it believes that glibc provides a ::gets in cases where
13250 // it does not. The issue was fixed in libstdc++ 6.3 (2016-12-21) and later.
13251 auto *II = NameInfo.getName().getAsIdentifierInfo();
13252 if (getLangOpts().CPlusPlus14 && II && II->isStr(Str: "gets") &&
13253 CurContext->isStdNamespace() &&
13254 isa<TranslationUnitDecl>(Val: LookupContext) &&
13255 PP.NeedsStdLibCxxWorkaroundBefore(FixedVersion: 2016'12'21) &&
13256 getSourceManager().isInSystemHeader(Loc: UsingLoc))
13257 return nullptr;
13258 UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
13259 dyn_cast<CXXRecordDecl>(Val: CurContext));
13260 if (TypoCorrection Corrected =
13261 CorrectTypo(Typo: R.getLookupNameInfo(), LookupKind: R.getLookupKind(), S, SS: &SS, CCC,
13262 Mode: CorrectTypoKind::ErrorRecovery)) {
13263 // We reject candidates where DroppedSpecifier == true, hence the
13264 // literal '0' below.
13265 diagnoseTypo(Correction: Corrected, TypoDiag: PDiag(DiagID: diag::err_no_member_suggest)
13266 << NameInfo.getName() << LookupContext << 0
13267 << SS.getRange());
13268
13269 // If we picked a correction with no attached Decl we can't do anything
13270 // useful with it, bail out.
13271 NamedDecl *ND = Corrected.getCorrectionDecl();
13272 if (!ND)
13273 return BuildInvalid();
13274
13275 // If we corrected to an inheriting constructor, handle it as one.
13276 auto *RD = dyn_cast<CXXRecordDecl>(Val: ND);
13277 if (RD && RD->isInjectedClassName()) {
13278 // The parent of the injected class name is the class itself.
13279 RD = cast<CXXRecordDecl>(Val: RD->getParent());
13280
13281 // Fix up the information we'll use to build the using declaration.
13282 if (Corrected.WillReplaceSpecifier()) {
13283 NestedNameSpecifierLocBuilder Builder;
13284 Builder.MakeTrivial(Context, Qualifier: Corrected.getCorrectionSpecifier(),
13285 R: QualifierLoc.getSourceRange());
13286 QualifierLoc = Builder.getWithLocInContext(Context);
13287 }
13288
13289 // In this case, the name we introduce is the name of a derived class
13290 // constructor.
13291 auto *CurClass = cast<CXXRecordDecl>(Val: CurContext);
13292 UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
13293 Ty: Context.getCanonicalTagType(TD: CurClass)));
13294 UsingName.setNamedTypeInfo(nullptr);
13295 for (auto *Ctor : LookupConstructors(Class: RD))
13296 R.addDecl(D: Ctor);
13297 R.resolveKind();
13298 } else {
13299 // FIXME: Pick up all the declarations if we found an overloaded
13300 // function.
13301 UsingName.setName(ND->getDeclName());
13302 R.addDecl(D: ND);
13303 }
13304 } else {
13305 Diag(Loc: IdentLoc, DiagID: diag::err_no_member)
13306 << NameInfo.getName() << LookupContext << SS.getRange();
13307 return BuildInvalid();
13308 }
13309 }
13310
13311 if (R.isAmbiguous())
13312 return BuildInvalid();
13313
13314 if (HasTypenameKeyword) {
13315 // If we asked for a typename and got a non-type decl, error out.
13316 if (!R.getAsSingle<TypeDecl>() &&
13317 !R.getAsSingle<UnresolvedUsingIfExistsDecl>()) {
13318 Diag(Loc: IdentLoc, DiagID: diag::err_using_typename_non_type);
13319 for (const NamedDecl *D : R)
13320 Diag(Loc: D->getUnderlyingDecl()->getLocation(),
13321 DiagID: diag::note_using_decl_target);
13322 return BuildInvalid();
13323 }
13324 } else {
13325 // If we asked for a non-typename and we got a type, error out,
13326 // but only if this is an instantiation of an unresolved using
13327 // decl. Otherwise just silently find the type name.
13328 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
13329 Diag(Loc: IdentLoc, DiagID: diag::err_using_dependent_value_is_type);
13330 Diag(Loc: R.getFoundDecl()->getLocation(), DiagID: diag::note_using_decl_target);
13331 return BuildInvalid();
13332 }
13333 }
13334
13335 // C++14 [namespace.udecl]p6:
13336 // A using-declaration shall not name a namespace.
13337 if (R.getAsSingle<NamespaceDecl>()) {
13338 Diag(Loc: IdentLoc, DiagID: diag::err_using_decl_can_not_refer_to_namespace)
13339 << SS.getRange();
13340 // Suggest using 'using namespace ...' instead.
13341 Diag(Loc: SS.getBeginLoc(), DiagID: diag::note_namespace_using_decl)
13342 << FixItHint::CreateInsertion(InsertionLoc: SS.getBeginLoc(), Code: "namespace ");
13343 return BuildInvalid();
13344 }
13345
13346 UsingDecl *UD = BuildValid();
13347
13348 // Some additional rules apply to inheriting constructors.
13349 if (UsingName.getName().getNameKind() ==
13350 DeclarationName::CXXConstructorName) {
13351 // Suppress access diagnostics; the access check is instead performed at the
13352 // point of use for an inheriting constructor.
13353 R.suppressDiagnostics();
13354 if (CheckInheritingConstructorUsingDecl(UD))
13355 return UD;
13356 }
13357
13358 for (NamedDecl *D : R) {
13359 UsingShadowDecl *PrevDecl = nullptr;
13360 if (!CheckUsingShadowDecl(BUD: UD, Orig: D, Previous, PrevShadow&: PrevDecl))
13361 BuildUsingShadowDecl(S, BUD: UD, Orig: D, PrevDecl);
13362 }
13363
13364 return UD;
13365}
13366
13367NamedDecl *Sema::BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
13368 SourceLocation UsingLoc,
13369 SourceLocation EnumLoc,
13370 SourceLocation NameLoc,
13371 TypeSourceInfo *EnumType,
13372 EnumDecl *ED) {
13373 bool Invalid = false;
13374
13375 if (CurContext->getRedeclContext()->isRecord()) {
13376 /// In class scope, check if this is a duplicate, for better a diagnostic.
13377 DeclarationNameInfo UsingEnumName(ED->getDeclName(), NameLoc);
13378 LookupResult Previous(*this, UsingEnumName, LookupUsingDeclName,
13379 RedeclarationKind::ForVisibleRedeclaration);
13380
13381 LookupQualifiedName(R&: Previous, LookupCtx: CurContext);
13382
13383 for (NamedDecl *D : Previous)
13384 if (UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(Val: D))
13385 if (UED->getEnumDecl() == ED) {
13386 Diag(Loc: UsingLoc, DiagID: diag::err_using_enum_decl_redeclaration)
13387 << SourceRange(EnumLoc, NameLoc);
13388 Diag(Loc: D->getLocation(), DiagID: diag::note_using_enum_decl) << 1;
13389 Invalid = true;
13390 break;
13391 }
13392 }
13393
13394 if (RequireCompleteEnumDecl(D: ED, L: NameLoc))
13395 Invalid = true;
13396
13397 UsingEnumDecl *UD = UsingEnumDecl::Create(C&: Context, DC: CurContext, UsingL: UsingLoc,
13398 EnumL: EnumLoc, NameL: NameLoc, EnumType);
13399 UD->setAccess(AS);
13400 CurContext->addDecl(D: UD);
13401
13402 if (Invalid) {
13403 UD->setInvalidDecl();
13404 return UD;
13405 }
13406
13407 // Create the shadow decls for each enumerator
13408 for (EnumConstantDecl *EC : ED->enumerators()) {
13409 UsingShadowDecl *PrevDecl = nullptr;
13410 DeclarationNameInfo DNI(EC->getDeclName(), EC->getLocation());
13411 LookupResult Previous(*this, DNI, LookupOrdinaryName,
13412 RedeclarationKind::ForVisibleRedeclaration);
13413 LookupName(R&: Previous, S);
13414 FilterUsingLookup(S, Previous);
13415
13416 if (!CheckUsingShadowDecl(BUD: UD, Orig: EC, Previous, PrevShadow&: PrevDecl))
13417 BuildUsingShadowDecl(S, BUD: UD, Orig: EC, PrevDecl);
13418 }
13419
13420 return UD;
13421}
13422
13423NamedDecl *Sema::BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
13424 ArrayRef<NamedDecl *> Expansions) {
13425 assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
13426 isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
13427 isa<UsingPackDecl>(InstantiatedFrom));
13428
13429 auto *UPD =
13430 UsingPackDecl::Create(C&: Context, DC: CurContext, InstantiatedFrom, UsingDecls: Expansions);
13431 UPD->setAccess(InstantiatedFrom->getAccess());
13432 CurContext->addDecl(D: UPD);
13433 return UPD;
13434}
13435
13436bool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) {
13437 assert(!UD->hasTypename() && "expecting a constructor name");
13438
13439 QualType SourceType(UD->getQualifier().getAsType(), 0);
13440 CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(Val: CurContext);
13441
13442 // Check whether the named type is a direct base class.
13443 bool AnyDependentBases = false;
13444 auto *Base =
13445 findDirectBaseWithType(Derived: TargetClass, DesiredBase: SourceType, AnyDependentBases);
13446 if (!Base && !AnyDependentBases) {
13447 Diag(Loc: UD->getUsingLoc(), DiagID: diag::err_using_decl_constructor_not_in_direct_base)
13448 << UD->getNameInfo().getSourceRange() << SourceType << TargetClass;
13449 UD->setInvalidDecl();
13450 return true;
13451 }
13452
13453 if (Base)
13454 Base->setInheritConstructors();
13455
13456 return false;
13457}
13458
13459bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
13460 bool HasTypenameKeyword,
13461 const CXXScopeSpec &SS,
13462 SourceLocation NameLoc,
13463 const LookupResult &Prev) {
13464 NestedNameSpecifier Qual = SS.getScopeRep();
13465
13466 // C++03 [namespace.udecl]p8:
13467 // C++0x [namespace.udecl]p10:
13468 // A using-declaration is a declaration and can therefore be used
13469 // repeatedly where (and only where) multiple declarations are
13470 // allowed.
13471 //
13472 // That's in non-member contexts.
13473 if (!CurContext->getRedeclContext()->isRecord()) {
13474 // A dependent qualifier outside a class can only ever resolve to an
13475 // enumeration type. Therefore it conflicts with any other non-type
13476 // declaration in the same scope.
13477 // FIXME: How should we check for dependent type-type conflicts at block
13478 // scope?
13479 if (Qual.isDependent() && !HasTypenameKeyword) {
13480 for (auto *D : Prev) {
13481 if (!isa<TypeDecl>(Val: D) && !isa<UsingDecl>(Val: D) && !isa<UsingPackDecl>(Val: D)) {
13482 bool OldCouldBeEnumerator =
13483 isa<UnresolvedUsingValueDecl>(Val: D) || isa<EnumConstantDecl>(Val: D);
13484 Diag(Loc: NameLoc,
13485 DiagID: OldCouldBeEnumerator ? diag::err_redefinition
13486 : diag::err_redefinition_different_kind)
13487 << Prev.getLookupName();
13488 Diag(Loc: D->getLocation(), DiagID: diag::note_previous_definition);
13489 return true;
13490 }
13491 }
13492 }
13493 return false;
13494 }
13495
13496 NestedNameSpecifier CNNS = Qual.getCanonical();
13497 for (const NamedDecl *D : Prev) {
13498 bool DTypename;
13499 NestedNameSpecifier DQual = std::nullopt;
13500 if (const auto *UD = dyn_cast<UsingDecl>(Val: D)) {
13501 DTypename = UD->hasTypename();
13502 DQual = UD->getQualifier();
13503 } else if (const auto *UD = dyn_cast<UnresolvedUsingValueDecl>(Val: D)) {
13504 DTypename = false;
13505 DQual = UD->getQualifier();
13506 } else if (const auto *UD = dyn_cast<UnresolvedUsingTypenameDecl>(Val: D)) {
13507 DTypename = true;
13508 DQual = UD->getQualifier();
13509 } else
13510 continue;
13511
13512 // using decls differ if one says 'typename' and the other doesn't.
13513 // FIXME: non-dependent using decls?
13514 if (HasTypenameKeyword != DTypename) continue;
13515
13516 // using decls differ if they name different scopes (but note that
13517 // template instantiation can cause this check to trigger when it
13518 // didn't before instantiation).
13519 if (CNNS != DQual.getCanonical())
13520 continue;
13521
13522 Diag(Loc: NameLoc, DiagID: diag::err_using_decl_redeclaration) << SS.getRange();
13523 Diag(Loc: D->getLocation(), DiagID: diag::note_using_decl) << 1;
13524 return true;
13525 }
13526
13527 return false;
13528}
13529
13530bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename,
13531 const CXXScopeSpec &SS,
13532 const DeclarationNameInfo &NameInfo,
13533 SourceLocation NameLoc,
13534 const LookupResult *R, const UsingDecl *UD) {
13535 DeclContext *NamedContext = computeDeclContext(SS);
13536 assert(bool(NamedContext) == (R || UD) && !(R && UD) &&
13537 "resolvable context must have exactly one set of decls");
13538
13539 // C++ 20 permits using an enumerator that does not have a class-hierarchy
13540 // relationship.
13541 bool Cxx20Enumerator = false;
13542 if (NamedContext) {
13543 EnumConstantDecl *EC = nullptr;
13544 if (R)
13545 EC = R->getAsSingle<EnumConstantDecl>();
13546 else if (UD && UD->shadow_size() == 1)
13547 EC = dyn_cast<EnumConstantDecl>(Val: UD->shadow_begin()->getTargetDecl());
13548 if (EC)
13549 Cxx20Enumerator = getLangOpts().CPlusPlus20;
13550
13551 if (auto *ED = dyn_cast<EnumDecl>(Val: NamedContext)) {
13552 // C++14 [namespace.udecl]p7:
13553 // A using-declaration shall not name a scoped enumerator.
13554 // C++20 p1099 permits enumerators.
13555 if (EC && R && ED->isScoped())
13556 Diag(Loc: SS.getBeginLoc(),
13557 DiagID: getLangOpts().CPlusPlus20
13558 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator
13559 : diag::ext_using_decl_scoped_enumerator)
13560 << SS.getRange();
13561
13562 // We want to consider the scope of the enumerator
13563 NamedContext = ED->getDeclContext();
13564 }
13565 }
13566
13567 if (!CurContext->isRecord()) {
13568 // C++03 [namespace.udecl]p3:
13569 // C++0x [namespace.udecl]p8:
13570 // A using-declaration for a class member shall be a member-declaration.
13571 // C++20 [namespace.udecl]p7
13572 // ... other than an enumerator ...
13573
13574 // If we weren't able to compute a valid scope, it might validly be a
13575 // dependent class or enumeration scope. If we have a 'typename' keyword,
13576 // the scope must resolve to a class type.
13577 if (NamedContext ? !NamedContext->getRedeclContext()->isRecord()
13578 : !HasTypename)
13579 return false; // OK
13580
13581 Diag(Loc: NameLoc,
13582 DiagID: Cxx20Enumerator
13583 ? diag::warn_cxx17_compat_using_decl_class_member_enumerator
13584 : diag::err_using_decl_can_not_refer_to_class_member)
13585 << SS.getRange();
13586
13587 if (Cxx20Enumerator)
13588 return false; // OK
13589
13590 auto *RD = NamedContext
13591 ? cast<CXXRecordDecl>(Val: NamedContext->getRedeclContext())
13592 : nullptr;
13593 if (RD && !RequireCompleteDeclContext(SS&: const_cast<CXXScopeSpec &>(SS), DC: RD)) {
13594 // See if there's a helpful fixit
13595
13596 if (!R) {
13597 // We will have already diagnosed the problem on the template
13598 // definition, Maybe we should do so again?
13599 } else if (R->getAsSingle<TypeDecl>()) {
13600 if (getLangOpts().CPlusPlus11) {
13601 // Convert 'using X::Y;' to 'using Y = X::Y;'.
13602 Diag(Loc: SS.getBeginLoc(), DiagID: diag::note_using_decl_class_member_workaround)
13603 << diag::MemClassWorkaround::AliasDecl
13604 << FixItHint::CreateInsertion(InsertionLoc: SS.getBeginLoc(),
13605 Code: NameInfo.getName().getAsString() +
13606 " = ");
13607 } else {
13608 // Convert 'using X::Y;' to 'typedef X::Y Y;'.
13609 SourceLocation InsertLoc = getLocForEndOfToken(Loc: NameInfo.getEndLoc());
13610 Diag(Loc: InsertLoc, DiagID: diag::note_using_decl_class_member_workaround)
13611 << diag::MemClassWorkaround::TypedefDecl
13612 << FixItHint::CreateReplacement(RemoveRange: UsingLoc, Code: "typedef")
13613 << FixItHint::CreateInsertion(
13614 InsertionLoc: InsertLoc, Code: " " + NameInfo.getName().getAsString());
13615 }
13616 } else if (R->getAsSingle<VarDecl>()) {
13617 // Don't provide a fixit outside C++11 mode; we don't want to suggest
13618 // repeating the type of the static data member here.
13619 FixItHint FixIt;
13620 if (getLangOpts().CPlusPlus11) {
13621 // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
13622 FixIt = FixItHint::CreateReplacement(
13623 RemoveRange: UsingLoc, Code: "auto &" + NameInfo.getName().getAsString() + " = ");
13624 }
13625
13626 Diag(Loc: UsingLoc, DiagID: diag::note_using_decl_class_member_workaround)
13627 << diag::MemClassWorkaround::ReferenceDecl << FixIt;
13628 } else if (R->getAsSingle<EnumConstantDecl>()) {
13629 // Don't provide a fixit outside C++11 mode; we don't want to suggest
13630 // repeating the type of the enumeration here, and we can't do so if
13631 // the type is anonymous.
13632 FixItHint FixIt;
13633 if (getLangOpts().CPlusPlus11) {
13634 // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
13635 FixIt = FixItHint::CreateReplacement(
13636 RemoveRange: UsingLoc,
13637 Code: "constexpr auto " + NameInfo.getName().getAsString() + " = ");
13638 }
13639
13640 Diag(Loc: UsingLoc, DiagID: diag::note_using_decl_class_member_workaround)
13641 << (getLangOpts().CPlusPlus11
13642 ? diag::MemClassWorkaround::ConstexprVar
13643 : diag::MemClassWorkaround::ConstVar)
13644 << FixIt;
13645 }
13646 }
13647
13648 return true; // Fail
13649 }
13650
13651 // If the named context is dependent, we can't decide much.
13652 if (!NamedContext) {
13653 // FIXME: in C++0x, we can diagnose if we can prove that the
13654 // nested-name-specifier does not refer to a base class, which is
13655 // still possible in some cases.
13656
13657 // Otherwise we have to conservatively report that things might be
13658 // okay.
13659 return false;
13660 }
13661
13662 // The current scope is a record.
13663 if (!NamedContext->isRecord()) {
13664 // Ideally this would point at the last name in the specifier,
13665 // but we don't have that level of source info.
13666 Diag(Loc: SS.getBeginLoc(),
13667 DiagID: Cxx20Enumerator
13668 ? diag::warn_cxx17_compat_using_decl_non_member_enumerator
13669 : diag::err_using_decl_nested_name_specifier_is_not_class)
13670 << SS.getScopeRep() << SS.getRange();
13671
13672 if (Cxx20Enumerator)
13673 return false; // OK
13674
13675 return true;
13676 }
13677
13678 if (!NamedContext->isDependentContext() &&
13679 RequireCompleteDeclContext(SS&: const_cast<CXXScopeSpec&>(SS), DC: NamedContext))
13680 return true;
13681
13682 // C++26 [namespace.udecl]p3:
13683 // In a using-declaration used as a member-declaration, each
13684 // using-declarator shall either name an enumerator or have a
13685 // nested-name-specifier naming a base class of the current class
13686 // ([expr.prim.this]). ...
13687 // "have a nested-name-specifier naming a base class of the current class"
13688 // was introduced by CWG400.
13689
13690 if (cast<CXXRecordDecl>(Val: CurContext)
13691 ->isProvablyNotDerivedFrom(Base: cast<CXXRecordDecl>(Val: NamedContext))) {
13692
13693 if (Cxx20Enumerator) {
13694 Diag(Loc: NameLoc, DiagID: diag::warn_cxx17_compat_using_decl_non_member_enumerator)
13695 << SS.getScopeRep() << SS.getRange();
13696 return false;
13697 }
13698
13699 if (CurContext == NamedContext) {
13700 Diag(Loc: SS.getBeginLoc(),
13701 DiagID: diag::err_using_decl_nested_name_specifier_is_current_class)
13702 << SS.getRange();
13703 return true;
13704 }
13705
13706 if (!cast<CXXRecordDecl>(Val: NamedContext)->isInvalidDecl()) {
13707 Diag(Loc: SS.getBeginLoc(),
13708 DiagID: diag::err_using_decl_nested_name_specifier_is_not_base_class)
13709 << SS.getScopeRep() << cast<CXXRecordDecl>(Val: CurContext)
13710 << SS.getRange();
13711 }
13712 return true;
13713 }
13714
13715 return false;
13716}
13717
13718Decl *Sema::ActOnAliasDeclaration(Scope *S, AccessSpecifier AS,
13719 MultiTemplateParamsArg TemplateParamLists,
13720 SourceLocation UsingLoc, UnqualifiedId &Name,
13721 const ParsedAttributesView &AttrList,
13722 TypeResult Type, Decl *DeclFromDeclSpec) {
13723
13724 if (Type.isInvalid())
13725 return nullptr;
13726
13727 bool Invalid = false;
13728 DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
13729 TypeSourceInfo *TInfo = nullptr;
13730 GetTypeFromParser(Ty: Type.get(), TInfo: &TInfo);
13731
13732 if (DiagnoseClassNameShadow(DC: CurContext, Info: NameInfo))
13733 return nullptr;
13734
13735 if (DiagnoseUnexpandedParameterPack(Loc: Name.StartLocation, T: TInfo,
13736 UPPC: UPPC_DeclarationType)) {
13737 Invalid = true;
13738 TInfo = Context.getTrivialTypeSourceInfo(T: Context.IntTy,
13739 Loc: TInfo->getTypeLoc().getBeginLoc());
13740 }
13741
13742 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
13743 TemplateParamLists.size()
13744 ? forRedeclarationInCurContext()
13745 : RedeclarationKind::ForVisibleRedeclaration);
13746 LookupName(R&: Previous, S);
13747
13748 // Warn about shadowing the name of a template parameter.
13749 if (Previous.isSingleResult() &&
13750 Previous.getFoundDecl()->isTemplateParameter()) {
13751 DiagnoseTemplateParameterShadow(Loc: Name.StartLocation,PrevDecl: Previous.getFoundDecl());
13752 Previous.clear();
13753 }
13754
13755 assert(Name.getKind() == UnqualifiedIdKind::IK_Identifier &&
13756 "name in alias declaration must be an identifier");
13757 TypeAliasDecl *NewTD = TypeAliasDecl::Create(C&: Context, DC: CurContext, StartLoc: UsingLoc,
13758 IdLoc: Name.StartLocation,
13759 Id: Name.Identifier, TInfo);
13760
13761 NewTD->setAccess(AS);
13762
13763 if (Invalid)
13764 NewTD->setInvalidDecl();
13765
13766 ProcessDeclAttributeList(S, D: NewTD, AttrList);
13767 AddPragmaAttributes(S, D: NewTD);
13768 ProcessAPINotes(D: NewTD);
13769
13770 CheckTypedefForVariablyModifiedType(S, D: NewTD);
13771 Invalid |= NewTD->isInvalidDecl();
13772
13773 // Get the innermost enclosing declaration scope.
13774 S = S->getDeclParent();
13775
13776 bool Redeclaration = false;
13777
13778 NamedDecl *NewND;
13779 if (TemplateParamLists.size()) {
13780 TypeAliasTemplateDecl *OldDecl = nullptr;
13781 TemplateParameterList *OldTemplateParams = nullptr;
13782
13783 if (TemplateParamLists.size() != 1) {
13784 Diag(Loc: UsingLoc, DiagID: diag::err_alias_template_extra_headers)
13785 << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
13786 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13787 Invalid = true;
13788 }
13789 TemplateParameterList *TemplateParams = TemplateParamLists[0];
13790
13791 // Check that we can declare a template here.
13792 if (CheckTemplateDeclScope(S, TemplateParams))
13793 return nullptr;
13794
13795 // Only consider previous declarations in the same scope.
13796 FilterLookupForScope(R&: Previous, Ctx: CurContext, S, /*ConsiderLinkage*/false,
13797 /*ExplicitInstantiationOrSpecialization*/AllowInlineNamespace: false);
13798 if (!Previous.empty()) {
13799 Redeclaration = true;
13800
13801 OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
13802 if (!OldDecl && !Invalid) {
13803 Diag(Loc: UsingLoc, DiagID: diag::err_redefinition_different_kind)
13804 << Name.Identifier;
13805
13806 NamedDecl *OldD = Previous.getRepresentativeDecl();
13807 if (OldD->getLocation().isValid())
13808 Diag(Loc: OldD->getLocation(), DiagID: diag::note_previous_definition);
13809
13810 Invalid = true;
13811 }
13812
13813 if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
13814 if (TemplateParameterListsAreEqual(New: TemplateParams,
13815 Old: OldDecl->getTemplateParameters(),
13816 /*Complain=*/true,
13817 Kind: TPL_TemplateMatch))
13818 OldTemplateParams =
13819 OldDecl->getMostRecentDecl()->getTemplateParameters();
13820 else
13821 Invalid = true;
13822
13823 TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
13824 if (!Invalid &&
13825 !Context.hasSameType(T1: OldTD->getUnderlyingType(),
13826 T2: NewTD->getUnderlyingType())) {
13827 // FIXME: The C++0x standard does not clearly say this is ill-formed,
13828 // but we can't reasonably accept it.
13829 Diag(Loc: NewTD->getLocation(), DiagID: diag::err_redefinition_different_typedef)
13830 << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
13831 if (OldTD->getLocation().isValid())
13832 Diag(Loc: OldTD->getLocation(), DiagID: diag::note_previous_definition);
13833 Invalid = true;
13834 }
13835 }
13836 }
13837
13838 // Merge any previous default template arguments into our parameters,
13839 // and check the parameter list.
13840 if (CheckTemplateParameterList(NewParams: TemplateParams, OldParams: OldTemplateParams,
13841 TPC: TPC_Other))
13842 return nullptr;
13843
13844 TypeAliasTemplateDecl *NewDecl =
13845 TypeAliasTemplateDecl::Create(C&: Context, DC: CurContext, L: UsingLoc,
13846 Name: Name.Identifier, Params: TemplateParams,
13847 Decl: NewTD);
13848 NewTD->setDescribedAliasTemplate(NewDecl);
13849
13850 NewDecl->setAccess(AS);
13851
13852 if (Invalid)
13853 NewDecl->setInvalidDecl();
13854 else if (OldDecl) {
13855 NewDecl->setPreviousDecl(OldDecl);
13856 CheckRedeclarationInModule(New: NewDecl, Old: OldDecl);
13857 }
13858
13859 NewND = NewDecl;
13860 } else {
13861 if (auto *TD = dyn_cast_or_null<TagDecl>(Val: DeclFromDeclSpec)) {
13862 setTagNameForLinkagePurposes(TagFromDeclSpec: TD, NewTD);
13863 handleTagNumbering(Tag: TD, TagScope: S);
13864 }
13865 ActOnTypedefNameDecl(S, DC: CurContext, D: NewTD, Previous, Redeclaration);
13866 NewND = NewTD;
13867 }
13868
13869 PushOnScopeChains(D: NewND, S);
13870 ActOnDocumentableDecl(D: NewND);
13871 return NewND;
13872}
13873
13874Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc,
13875 SourceLocation AliasLoc,
13876 IdentifierInfo *Alias, CXXScopeSpec &SS,
13877 SourceLocation IdentLoc,
13878 IdentifierInfo *Ident) {
13879
13880 // Lookup the namespace name.
13881 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
13882 LookupParsedName(R, S, SS: &SS, /*ObjectType=*/QualType());
13883
13884 if (R.isAmbiguous())
13885 return nullptr;
13886
13887 if (R.empty()) {
13888 if (!TryNamespaceTypoCorrection(S&: *this, R, Sc: S, SS, IdentLoc, Ident)) {
13889 Diag(Loc: IdentLoc, DiagID: diag::err_expected_namespace_name) << SS.getRange();
13890 return nullptr;
13891 }
13892 }
13893 assert(!R.isAmbiguous() && !R.empty());
13894 auto *ND = cast<NamespaceBaseDecl>(Val: R.getRepresentativeDecl());
13895
13896 // Check if we have a previous declaration with the same name.
13897 LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
13898 RedeclarationKind::ForVisibleRedeclaration);
13899 LookupName(R&: PrevR, S);
13900
13901 // Check we're not shadowing a template parameter.
13902 if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
13903 DiagnoseTemplateParameterShadow(Loc: AliasLoc, PrevDecl: PrevR.getFoundDecl());
13904 PrevR.clear();
13905 }
13906
13907 // Filter out any other lookup result from an enclosing scope.
13908 FilterLookupForScope(R&: PrevR, Ctx: CurContext, S, /*ConsiderLinkage*/false,
13909 /*AllowInlineNamespace*/false);
13910
13911 // Find the previous declaration and check that we can redeclare it.
13912 NamespaceAliasDecl *Prev = nullptr;
13913 if (PrevR.isSingleResult()) {
13914 NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
13915 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(Val: PrevDecl)) {
13916 // We already have an alias with the same name that points to the same
13917 // namespace; check that it matches.
13918 if (AD->getNamespace()->Equals(DC: getNamespaceDecl(D: ND))) {
13919 Prev = AD;
13920 } else if (isVisible(D: PrevDecl)) {
13921 Diag(Loc: AliasLoc, DiagID: diag::err_redefinition_different_namespace_alias)
13922 << Alias;
13923 Diag(Loc: AD->getLocation(), DiagID: diag::note_previous_namespace_alias)
13924 << AD->getNamespace();
13925 return nullptr;
13926 }
13927 } else if (isVisible(D: PrevDecl)) {
13928 unsigned DiagID = isa<NamespaceDecl>(Val: PrevDecl->getUnderlyingDecl())
13929 ? diag::err_redefinition
13930 : diag::err_redefinition_different_kind;
13931 Diag(Loc: AliasLoc, DiagID) << Alias;
13932 Diag(Loc: PrevDecl->getLocation(), DiagID: diag::note_previous_definition);
13933 return nullptr;
13934 }
13935 }
13936
13937 // The use of a nested name specifier may trigger deprecation warnings.
13938 DiagnoseUseOfDecl(D: ND, Locs: IdentLoc);
13939
13940 NamespaceAliasDecl *AliasDecl =
13941 NamespaceAliasDecl::Create(C&: Context, DC: CurContext, NamespaceLoc, AliasLoc,
13942 Alias, QualifierLoc: SS.getWithLocInContext(Context),
13943 IdentLoc, Namespace: ND);
13944 if (Prev)
13945 AliasDecl->setPreviousDecl(Prev);
13946
13947 PushOnScopeChains(D: AliasDecl, S);
13948 return AliasDecl;
13949}
13950
13951namespace {
13952struct SpecialMemberExceptionSpecInfo
13953 : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
13954 SourceLocation Loc;
13955 Sema::ImplicitExceptionSpecification ExceptSpec;
13956
13957 SpecialMemberExceptionSpecInfo(Sema &S, CXXMethodDecl *MD,
13958 CXXSpecialMemberKind CSM,
13959 Sema::InheritedConstructorInfo *ICI,
13960 SourceLocation Loc)
13961 : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
13962
13963 bool visitBase(CXXBaseSpecifier *Base);
13964 bool visitField(FieldDecl *FD);
13965
13966 void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
13967 unsigned Quals);
13968
13969 void visitSubobjectCall(Subobject Subobj,
13970 Sema::SpecialMemberOverloadResult SMOR);
13971};
13972}
13973
13974bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
13975 auto *BaseClass = Base->getType()->getAsCXXRecordDecl();
13976 if (!BaseClass)
13977 return false;
13978
13979 Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(Class: BaseClass);
13980 if (auto *BaseCtor = SMOR.getMethod()) {
13981 visitSubobjectCall(Subobj: Base, SMOR: BaseCtor);
13982 return false;
13983 }
13984
13985 visitClassSubobject(Class: BaseClass, Subobj: Base, Quals: 0);
13986 return false;
13987}
13988
13989bool SpecialMemberExceptionSpecInfo::visitField(FieldDecl *FD) {
13990 if (CSM == CXXSpecialMemberKind::DefaultConstructor &&
13991 FD->hasInClassInitializer()) {
13992 Expr *E = FD->getInClassInitializer();
13993 if (!E)
13994 // FIXME: It's a little wasteful to build and throw away a
13995 // CXXDefaultInitExpr here.
13996 // FIXME: We should have a single context note pointing at Loc, and
13997 // this location should be MD->getLocation() instead, since that's
13998 // the location where we actually use the default init expression.
13999 E = S.BuildCXXDefaultInitExpr(Loc, Field: FD).get();
14000 if (E)
14001 ExceptSpec.CalledExpr(E);
14002 } else if (auto *RD = S.Context.getBaseElementType(QT: FD->getType())
14003 ->getAsCXXRecordDecl()) {
14004 visitClassSubobject(Class: RD, Subobj: FD, Quals: FD->getType().getCVRQualifiers());
14005 }
14006 return false;
14007}
14008
14009void SpecialMemberExceptionSpecInfo::visitClassSubobject(CXXRecordDecl *Class,
14010 Subobject Subobj,
14011 unsigned Quals) {
14012 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
14013 bool IsMutable = Field && Field->isMutable();
14014 visitSubobjectCall(Subobj, SMOR: lookupIn(Class, Quals, IsMutable));
14015}
14016
14017void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
14018 Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR) {
14019 // Note, if lookup fails, it doesn't matter what exception specification we
14020 // choose because the special member will be deleted.
14021 if (CXXMethodDecl *MD = SMOR.getMethod())
14022 ExceptSpec.CalledDecl(CallLoc: getSubobjectLoc(Subobj), Method: MD);
14023}
14024
14025bool Sema::tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec) {
14026 llvm::APSInt Result;
14027 ExprResult Converted = CheckConvertedConstantExpression(
14028 From: ExplicitSpec.getExpr(), T: Context.BoolTy, Value&: Result, CCE: CCEKind::ExplicitBool);
14029 ExplicitSpec.setExpr(Converted.get());
14030 if (Converted.isUsable() && !Converted.get()->isValueDependent()) {
14031 ExplicitSpec.setKind(Result.getBoolValue()
14032 ? ExplicitSpecKind::ResolvedTrue
14033 : ExplicitSpecKind::ResolvedFalse);
14034 return true;
14035 }
14036 ExplicitSpec.setKind(ExplicitSpecKind::Unresolved);
14037 return false;
14038}
14039
14040ExplicitSpecifier Sema::ActOnExplicitBoolSpecifier(Expr *ExplicitExpr) {
14041 ExplicitSpecifier ES(ExplicitExpr, ExplicitSpecKind::Unresolved);
14042 if (!ExplicitExpr->isTypeDependent())
14043 tryResolveExplicitSpecifier(ExplicitSpec&: ES);
14044 return ES;
14045}
14046
14047static Sema::ImplicitExceptionSpecification
14048ComputeDefaultedSpecialMemberExceptionSpec(
14049 Sema &S, SourceLocation Loc, CXXMethodDecl *MD, CXXSpecialMemberKind CSM,
14050 Sema::InheritedConstructorInfo *ICI) {
14051 ComputingExceptionSpec CES(S, MD, Loc);
14052
14053 CXXRecordDecl *ClassDecl = MD->getParent();
14054
14055 // C++ [except.spec]p14:
14056 // An implicitly declared special member function (Clause 12) shall have an
14057 // exception-specification. [...]
14058 SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->getLocation());
14059 if (ClassDecl->isInvalidDecl())
14060 return Info.ExceptSpec;
14061
14062 // FIXME: If this diagnostic fires, we're probably missing a check for
14063 // attempting to resolve an exception specification before it's known
14064 // at a higher level.
14065 if (S.RequireCompleteType(Loc: MD->getLocation(),
14066 T: S.Context.getCanonicalTagType(TD: ClassDecl),
14067 DiagID: diag::err_exception_spec_incomplete_type))
14068 return Info.ExceptSpec;
14069
14070 // C++1z [except.spec]p7:
14071 // [Look for exceptions thrown by] a constructor selected [...] to
14072 // initialize a potentially constructed subobject,
14073 // C++1z [except.spec]p8:
14074 // The exception specification for an implicitly-declared destructor, or a
14075 // destructor without a noexcept-specifier, is potentially-throwing if and
14076 // only if any of the destructors for any of its potentially constructed
14077 // subojects is potentially throwing.
14078 // FIXME: We respect the first rule but ignore the "potentially constructed"
14079 // in the second rule to resolve a core issue (no number yet) that would have
14080 // us reject:
14081 // struct A { virtual void f() = 0; virtual ~A() noexcept(false) = 0; };
14082 // struct B : A {};
14083 // struct C : B { void f(); };
14084 // ... due to giving B::~B() a non-throwing exception specification.
14085 Info.visit(Bases: Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
14086 : Info.VisitAllBases);
14087
14088 return Info.ExceptSpec;
14089}
14090
14091namespace {
14092/// RAII object to register a special member as being currently declared.
14093struct DeclaringSpecialMember {
14094 Sema &S;
14095 Sema::SpecialMemberDecl D;
14096 Sema::ContextRAII SavedContext;
14097 bool WasAlreadyBeingDeclared;
14098
14099 DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM)
14100 : S(S), D(RD, CSM), SavedContext(S, RD) {
14101 WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(Ptr: D).second;
14102 if (WasAlreadyBeingDeclared)
14103 // This almost never happens, but if it does, ensure that our cache
14104 // doesn't contain a stale result.
14105 S.SpecialMemberCache.clear();
14106 else {
14107 // Register a note to be produced if we encounter an error while
14108 // declaring the special member.
14109 Sema::CodeSynthesisContext Ctx;
14110 Ctx.Kind = Sema::CodeSynthesisContext::DeclaringSpecialMember;
14111 // FIXME: We don't have a location to use here. Using the class's
14112 // location maintains the fiction that we declare all special members
14113 // with the class, but (1) it's not clear that lying about that helps our
14114 // users understand what's going on, and (2) there may be outer contexts
14115 // on the stack (some of which are relevant) and printing them exposes
14116 // our lies.
14117 Ctx.PointOfInstantiation = RD->getLocation();
14118 Ctx.Entity = RD;
14119 Ctx.SpecialMember = CSM;
14120 S.pushCodeSynthesisContext(Ctx);
14121 }
14122 }
14123 ~DeclaringSpecialMember() {
14124 if (!WasAlreadyBeingDeclared) {
14125 S.SpecialMembersBeingDeclared.erase(Ptr: D);
14126 S.popCodeSynthesisContext();
14127 }
14128 }
14129
14130 /// Are we already trying to declare this special member?
14131 bool isAlreadyBeingDeclared() const {
14132 return WasAlreadyBeingDeclared;
14133 }
14134};
14135}
14136
14137void Sema::CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD) {
14138 // Look up any existing declarations, but don't trigger declaration of all
14139 // implicit special members with this name.
14140 DeclarationName Name = FD->getDeclName();
14141 LookupResult R(*this, Name, SourceLocation(), LookupOrdinaryName,
14142 RedeclarationKind::ForExternalRedeclaration);
14143 for (auto *D : FD->getParent()->lookup(Name))
14144 if (auto *Acceptable = R.getAcceptableDecl(D))
14145 R.addDecl(D: Acceptable);
14146 R.resolveKind();
14147 R.suppressDiagnostics();
14148
14149 CheckFunctionDeclaration(S, NewFD: FD, Previous&: R, /*IsMemberSpecialization*/ false,
14150 DeclIsDefn: FD->isThisDeclarationADefinition());
14151}
14152
14153void Sema::setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
14154 QualType ResultTy,
14155 ArrayRef<QualType> Args) {
14156 // Build an exception specification pointing back at this constructor.
14157 FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(S&: *this, MD: SpecialMem);
14158
14159 LangAS AS = getDefaultCXXMethodAddrSpace();
14160 if (AS != LangAS::Default) {
14161 EPI.TypeQuals.addAddressSpace(space: AS);
14162 }
14163
14164 auto QT = Context.getFunctionType(ResultTy, Args, EPI);
14165 SpecialMem->setType(QT);
14166
14167 // During template instantiation of implicit special member functions we need
14168 // a reliable TypeSourceInfo for the function prototype in order to allow
14169 // functions to be substituted.
14170 if (inTemplateInstantiation() && isLambdaMethod(DC: SpecialMem)) {
14171 TypeSourceInfo *TSI =
14172 Context.getTrivialTypeSourceInfo(T: SpecialMem->getType());
14173 SpecialMem->setTypeSourceInfo(TSI);
14174 }
14175}
14176
14177CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
14178 CXXRecordDecl *ClassDecl) {
14179 // C++ [class.ctor]p5:
14180 // A default constructor for a class X is a constructor of class X
14181 // that can be called without an argument. If there is no
14182 // user-declared constructor for class X, a default constructor is
14183 // implicitly declared. An implicitly-declared default constructor
14184 // is an inline public member of its class.
14185 assert(ClassDecl->needsImplicitDefaultConstructor() &&
14186 "Should not build implicit default constructor!");
14187
14188 DeclaringSpecialMember DSM(*this, ClassDecl,
14189 CXXSpecialMemberKind::DefaultConstructor);
14190 if (DSM.isAlreadyBeingDeclared())
14191 return nullptr;
14192
14193 bool Constexpr = defaultedSpecialMemberIsConstexpr(
14194 S&: *this, ClassDecl, CSM: CXXSpecialMemberKind::DefaultConstructor, ConstArg: false);
14195
14196 // Create the actual constructor declaration.
14197 CanQualType ClassType = Context.getCanonicalTagType(TD: ClassDecl);
14198 SourceLocation ClassLoc = ClassDecl->getLocation();
14199 DeclarationName Name
14200 = Context.DeclarationNames.getCXXConstructorName(Ty: ClassType);
14201 DeclarationNameInfo NameInfo(Name, ClassLoc);
14202 CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
14203 C&: Context, RD: ClassDecl, StartLoc: ClassLoc, NameInfo, /*Type*/ T: QualType(),
14204 /*TInfo=*/nullptr, ES: ExplicitSpecifier(),
14205 UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
14206 /*isInline=*/true, /*isImplicitlyDeclared=*/true,
14207 ConstexprKind: Constexpr ? ConstexprSpecKind::Constexpr
14208 : ConstexprSpecKind::Unspecified);
14209 DefaultCon->setAccess(AS_public);
14210 DefaultCon->setDefaulted();
14211
14212 setupImplicitSpecialMemberType(SpecialMem: DefaultCon, ResultTy: Context.VoidTy, Args: {});
14213
14214 if (getLangOpts().CUDA)
14215 CUDA().inferTargetForImplicitSpecialMember(
14216 ClassDecl, CSM: CXXSpecialMemberKind::DefaultConstructor, MemberDecl: DefaultCon,
14217 /* ConstRHS */ false,
14218 /* Diagnose */ false);
14219
14220 // We don't need to use SpecialMemberIsTrivial here; triviality for default
14221 // constructors is easy to compute.
14222 DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
14223
14224 // Note that we have declared this constructor.
14225 ++getASTContext().NumImplicitDefaultConstructorsDeclared;
14226
14227 Scope *S = getScopeForContext(Ctx: ClassDecl);
14228 CheckImplicitSpecialMemberDeclaration(S, FD: DefaultCon);
14229
14230 if (ShouldDeleteSpecialMember(MD: DefaultCon,
14231 CSM: CXXSpecialMemberKind::DefaultConstructor))
14232 SetDeclDeleted(dcl: DefaultCon, DelLoc: ClassLoc);
14233
14234 if (S)
14235 PushOnScopeChains(D: DefaultCon, S, AddToContext: false);
14236 ClassDecl->addDecl(D: DefaultCon);
14237
14238 return DefaultCon;
14239}
14240
14241void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
14242 CXXConstructorDecl *Constructor) {
14243 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
14244 !Constructor->doesThisDeclarationHaveABody() &&
14245 !Constructor->isDeleted()) &&
14246 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
14247 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14248 return;
14249
14250 CXXRecordDecl *ClassDecl = Constructor->getParent();
14251 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
14252 if (ClassDecl->isInvalidDecl()) {
14253 return;
14254 }
14255
14256 SynthesizedFunctionScope Scope(*this, Constructor);
14257
14258 // The exception specification is needed because we are defining the
14259 // function.
14260 ResolveExceptionSpec(Loc: CurrentLocation,
14261 FPT: Constructor->getType()->castAs<FunctionProtoType>());
14262 MarkVTableUsed(Loc: CurrentLocation, Class: ClassDecl);
14263
14264 // Add a context note for diagnostics produced after this point.
14265 Scope.addContextNote(UseLoc: CurrentLocation);
14266
14267 if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
14268 Constructor->setInvalidDecl();
14269 return;
14270 }
14271
14272 SourceLocation Loc = Constructor->getEndLoc().isValid()
14273 ? Constructor->getEndLoc()
14274 : Constructor->getLocation();
14275 Constructor->setBody(new (Context) CompoundStmt(Loc));
14276 Constructor->markUsed(C&: Context);
14277
14278 if (ASTMutationListener *L = getASTMutationListener()) {
14279 L->CompletedImplicitDefinition(D: Constructor);
14280 }
14281
14282 DiagnoseUninitializedFields(SemaRef&: *this, Constructor);
14283}
14284
14285void Sema::ActOnFinishDelayedMemberInitializers(Decl *D) {
14286 // Perform any delayed checks on exception specifications.
14287 CheckDelayedMemberExceptionSpecs();
14288}
14289
14290/// Find or create the fake constructor we synthesize to model constructing an
14291/// object of a derived class via a constructor of a base class.
14292CXXConstructorDecl *
14293Sema::findInheritingConstructor(SourceLocation Loc,
14294 CXXConstructorDecl *BaseCtor,
14295 ConstructorUsingShadowDecl *Shadow) {
14296 CXXRecordDecl *Derived = Shadow->getParent();
14297 SourceLocation UsingLoc = Shadow->getLocation();
14298
14299 // FIXME: Add a new kind of DeclarationName for an inherited constructor.
14300 // For now we use the name of the base class constructor as a member of the
14301 // derived class to indicate a (fake) inherited constructor name.
14302 DeclarationName Name = BaseCtor->getDeclName();
14303
14304 // Check to see if we already have a fake constructor for this inherited
14305 // constructor call.
14306 for (NamedDecl *Ctor : Derived->lookup(Name))
14307 if (declaresSameEntity(D1: cast<CXXConstructorDecl>(Val: Ctor)
14308 ->getInheritedConstructor()
14309 .getConstructor(),
14310 D2: BaseCtor))
14311 return cast<CXXConstructorDecl>(Val: Ctor);
14312
14313 DeclarationNameInfo NameInfo(Name, UsingLoc);
14314 TypeSourceInfo *TInfo =
14315 Context.getTrivialTypeSourceInfo(T: BaseCtor->getType(), Loc: UsingLoc);
14316 FunctionProtoTypeLoc ProtoLoc =
14317 TInfo->getTypeLoc().IgnoreParens().castAs<FunctionProtoTypeLoc>();
14318
14319 // Check the inherited constructor is valid and find the list of base classes
14320 // from which it was inherited.
14321 InheritedConstructorInfo ICI(*this, Loc, Shadow);
14322
14323 bool Constexpr = BaseCtor->isConstexpr() &&
14324 defaultedSpecialMemberIsConstexpr(
14325 S&: *this, ClassDecl: Derived, CSM: CXXSpecialMemberKind::DefaultConstructor,
14326 ConstArg: false, InheritedCtor: BaseCtor, Inherited: &ICI);
14327
14328 CXXConstructorDecl *DerivedCtor = CXXConstructorDecl::Create(
14329 C&: Context, RD: Derived, StartLoc: UsingLoc, NameInfo, T: TInfo->getType(), TInfo,
14330 ES: BaseCtor->getExplicitSpecifier(), UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
14331 /*isInline=*/true,
14332 /*isImplicitlyDeclared=*/true,
14333 ConstexprKind: Constexpr ? BaseCtor->getConstexprKind() : ConstexprSpecKind::Unspecified,
14334 Inherited: InheritedConstructor(Shadow, BaseCtor),
14335 TrailingRequiresClause: BaseCtor->getTrailingRequiresClause());
14336 if (Shadow->isInvalidDecl())
14337 DerivedCtor->setInvalidDecl();
14338
14339 // Build an unevaluated exception specification for this fake constructor.
14340 const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
14341 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
14342 EPI.ExceptionSpec.Type = EST_Unevaluated;
14343 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
14344 DerivedCtor->setType(Context.getFunctionType(ResultTy: FPT->getReturnType(),
14345 Args: FPT->getParamTypes(), EPI));
14346
14347 // Build the parameter declarations.
14348 SmallVector<ParmVarDecl *, 16> ParamDecls;
14349 for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
14350 TypeSourceInfo *TInfo =
14351 Context.getTrivialTypeSourceInfo(T: FPT->getParamType(i: I), Loc: UsingLoc);
14352 ParmVarDecl *PD = ParmVarDecl::Create(
14353 C&: Context, DC: DerivedCtor, StartLoc: UsingLoc, IdLoc: UsingLoc, /*IdentifierInfo=*/Id: nullptr,
14354 T: FPT->getParamType(i: I), TInfo, S: SC_None, /*DefArg=*/nullptr);
14355 PD->setScopeInfo(scopeDepth: 0, parameterIndex: I);
14356 PD->setImplicit();
14357 // Ensure attributes are propagated onto parameters (this matters for
14358 // format, pass_object_size, ...).
14359 mergeDeclAttributes(New: PD, Old: BaseCtor->getParamDecl(i: I));
14360 ParamDecls.push_back(Elt: PD);
14361 ProtoLoc.setParam(i: I, VD: PD);
14362 }
14363
14364 // Set up the new constructor.
14365 assert(!BaseCtor->isDeleted() && "should not use deleted constructor");
14366 DerivedCtor->setAccess(BaseCtor->getAccess());
14367 DerivedCtor->setParams(ParamDecls);
14368 Derived->addDecl(D: DerivedCtor);
14369
14370 if (ShouldDeleteSpecialMember(MD: DerivedCtor,
14371 CSM: CXXSpecialMemberKind::DefaultConstructor, ICI: &ICI))
14372 SetDeclDeleted(dcl: DerivedCtor, DelLoc: UsingLoc);
14373
14374 return DerivedCtor;
14375}
14376
14377void Sema::NoteDeletedInheritingConstructor(CXXConstructorDecl *Ctor) {
14378 InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
14379 Ctor->getInheritedConstructor().getShadowDecl());
14380 ShouldDeleteSpecialMember(MD: Ctor, CSM: CXXSpecialMemberKind::DefaultConstructor,
14381 ICI: &ICI,
14382 /*Diagnose*/ true);
14383}
14384
14385void Sema::DefineInheritingConstructor(SourceLocation CurrentLocation,
14386 CXXConstructorDecl *Constructor) {
14387 CXXRecordDecl *ClassDecl = Constructor->getParent();
14388 assert(Constructor->getInheritedConstructor() &&
14389 !Constructor->doesThisDeclarationHaveABody() &&
14390 !Constructor->isDeleted());
14391 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14392 return;
14393
14394 // Initializations are performed "as if by a defaulted default constructor",
14395 // so enter the appropriate scope.
14396 SynthesizedFunctionScope Scope(*this, Constructor);
14397
14398 // The exception specification is needed because we are defining the
14399 // function.
14400 ResolveExceptionSpec(Loc: CurrentLocation,
14401 FPT: Constructor->getType()->castAs<FunctionProtoType>());
14402 MarkVTableUsed(Loc: CurrentLocation, Class: ClassDecl);
14403
14404 // Add a context note for diagnostics produced after this point.
14405 Scope.addContextNote(UseLoc: CurrentLocation);
14406
14407 ConstructorUsingShadowDecl *Shadow =
14408 Constructor->getInheritedConstructor().getShadowDecl();
14409 CXXConstructorDecl *InheritedCtor =
14410 Constructor->getInheritedConstructor().getConstructor();
14411
14412 // [class.inhctor.init]p1:
14413 // initialization proceeds as if a defaulted default constructor is used to
14414 // initialize the D object and each base class subobject from which the
14415 // constructor was inherited
14416
14417 InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
14418 CXXRecordDecl *RD = Shadow->getParent();
14419 SourceLocation InitLoc = Shadow->getLocation();
14420
14421 // Build explicit initializers for all base classes from which the
14422 // constructor was inherited.
14423 SmallVector<CXXCtorInitializer*, 8> Inits;
14424 for (bool VBase : {false, true}) {
14425 for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
14426 if (B.isVirtual() != VBase)
14427 continue;
14428
14429 auto *BaseRD = B.getType()->getAsCXXRecordDecl();
14430 if (!BaseRD)
14431 continue;
14432
14433 auto BaseCtor = ICI.findConstructorForBase(Base: BaseRD, Ctor: InheritedCtor);
14434 if (!BaseCtor.first)
14435 continue;
14436
14437 MarkFunctionReferenced(Loc: CurrentLocation, Func: BaseCtor.first);
14438 ExprResult Init = new (Context) CXXInheritedCtorInitExpr(
14439 InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
14440
14441 auto *TInfo = Context.getTrivialTypeSourceInfo(T: B.getType(), Loc: InitLoc);
14442 Inits.push_back(Elt: new (Context) CXXCtorInitializer(
14443 Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
14444 SourceLocation()));
14445 }
14446 }
14447
14448 // We now proceed as if for a defaulted default constructor, with the relevant
14449 // initializers replaced.
14450
14451 if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Initializers: Inits)) {
14452 Constructor->setInvalidDecl();
14453 return;
14454 }
14455
14456 Constructor->setBody(new (Context) CompoundStmt(InitLoc));
14457 Constructor->markUsed(C&: Context);
14458
14459 if (ASTMutationListener *L = getASTMutationListener()) {
14460 L->CompletedImplicitDefinition(D: Constructor);
14461 }
14462
14463 DiagnoseUninitializedFields(SemaRef&: *this, Constructor);
14464}
14465
14466CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) {
14467 // C++ [class.dtor]p2:
14468 // If a class has no user-declared destructor, a destructor is
14469 // declared implicitly. An implicitly-declared destructor is an
14470 // inline public member of its class.
14471 assert(ClassDecl->needsImplicitDestructor());
14472
14473 DeclaringSpecialMember DSM(*this, ClassDecl,
14474 CXXSpecialMemberKind::Destructor);
14475 if (DSM.isAlreadyBeingDeclared())
14476 return nullptr;
14477
14478 bool Constexpr = defaultedSpecialMemberIsConstexpr(
14479 S&: *this, ClassDecl, CSM: CXXSpecialMemberKind::Destructor, ConstArg: false);
14480
14481 // Create the actual destructor declaration.
14482 CanQualType ClassType = Context.getCanonicalTagType(TD: ClassDecl);
14483 SourceLocation ClassLoc = ClassDecl->getLocation();
14484 DeclarationName Name
14485 = Context.DeclarationNames.getCXXDestructorName(Ty: ClassType);
14486 DeclarationNameInfo NameInfo(Name, ClassLoc);
14487 CXXDestructorDecl *Destructor = CXXDestructorDecl::Create(
14488 C&: Context, RD: ClassDecl, StartLoc: ClassLoc, NameInfo, T: QualType(), TInfo: nullptr,
14489 UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
14490 /*isInline=*/true,
14491 /*isImplicitlyDeclared=*/true,
14492 ConstexprKind: Constexpr ? ConstexprSpecKind::Constexpr
14493 : ConstexprSpecKind::Unspecified);
14494 Destructor->setAccess(AS_public);
14495 Destructor->setDefaulted();
14496
14497 setupImplicitSpecialMemberType(SpecialMem: Destructor, ResultTy: Context.VoidTy, Args: {});
14498
14499 if (getLangOpts().CUDA)
14500 CUDA().inferTargetForImplicitSpecialMember(
14501 ClassDecl, CSM: CXXSpecialMemberKind::Destructor, MemberDecl: Destructor,
14502 /* ConstRHS */ false,
14503 /* Diagnose */ false);
14504
14505 // We don't need to use SpecialMemberIsTrivial here; triviality for
14506 // destructors is easy to compute.
14507 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
14508 Destructor->setTrivialForCall(ClassDecl->hasAttr<TrivialABIAttr>() ||
14509 ClassDecl->hasTrivialDestructorForCall());
14510
14511 // Note that we have declared this destructor.
14512 ++getASTContext().NumImplicitDestructorsDeclared;
14513
14514 Scope *S = getScopeForContext(Ctx: ClassDecl);
14515 CheckImplicitSpecialMemberDeclaration(S, FD: Destructor);
14516
14517 // We can't check whether an implicit destructor is deleted before we complete
14518 // the definition of the class, because its validity depends on the alignment
14519 // of the class. We'll check this from ActOnFields once the class is complete.
14520 if (ClassDecl->isCompleteDefinition() &&
14521 ShouldDeleteSpecialMember(MD: Destructor, CSM: CXXSpecialMemberKind::Destructor))
14522 SetDeclDeleted(dcl: Destructor, DelLoc: ClassLoc);
14523
14524 // Introduce this destructor into its scope.
14525 if (S)
14526 PushOnScopeChains(D: Destructor, S, AddToContext: false);
14527 ClassDecl->addDecl(D: Destructor);
14528
14529 return Destructor;
14530}
14531
14532void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
14533 CXXDestructorDecl *Destructor) {
14534 assert((Destructor->isDefaulted() &&
14535 !Destructor->doesThisDeclarationHaveABody() &&
14536 !Destructor->isDeleted()) &&
14537 "DefineImplicitDestructor - call it for implicit default dtor");
14538 if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
14539 return;
14540
14541 CXXRecordDecl *ClassDecl = Destructor->getParent();
14542 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
14543
14544 SynthesizedFunctionScope Scope(*this, Destructor);
14545
14546 // The exception specification is needed because we are defining the
14547 // function.
14548 ResolveExceptionSpec(Loc: CurrentLocation,
14549 FPT: Destructor->getType()->castAs<FunctionProtoType>());
14550 MarkVTableUsed(Loc: CurrentLocation, Class: ClassDecl);
14551
14552 // Add a context note for diagnostics produced after this point.
14553 Scope.addContextNote(UseLoc: CurrentLocation);
14554
14555 MarkBaseAndMemberDestructorsReferenced(Location: Destructor->getLocation(),
14556 ClassDecl: Destructor->getParent());
14557
14558 if (CheckDestructor(Destructor)) {
14559 Destructor->setInvalidDecl();
14560 return;
14561 }
14562
14563 SourceLocation Loc = Destructor->getEndLoc().isValid()
14564 ? Destructor->getEndLoc()
14565 : Destructor->getLocation();
14566 Destructor->setBody(new (Context) CompoundStmt(Loc));
14567 Destructor->markUsed(C&: Context);
14568
14569 if (ASTMutationListener *L = getASTMutationListener()) {
14570 L->CompletedImplicitDefinition(D: Destructor);
14571 }
14572}
14573
14574void Sema::CheckCompleteDestructorVariant(SourceLocation CurrentLocation,
14575 CXXDestructorDecl *Destructor) {
14576 if (Destructor->isInvalidDecl())
14577 return;
14578
14579 CXXRecordDecl *ClassDecl = Destructor->getParent();
14580 assert(Context.getTargetInfo().getCXXABI().isMicrosoft() &&
14581 "implicit complete dtors unneeded outside MS ABI");
14582 assert(ClassDecl->getNumVBases() > 0 &&
14583 "complete dtor only exists for classes with vbases");
14584
14585 SynthesizedFunctionScope Scope(*this, Destructor);
14586
14587 // Add a context note for diagnostics produced after this point.
14588 Scope.addContextNote(UseLoc: CurrentLocation);
14589
14590 MarkVirtualBaseDestructorsReferenced(Location: Destructor->getLocation(), ClassDecl);
14591}
14592
14593void Sema::ActOnFinishCXXMemberDecls() {
14594 // If the context is an invalid C++ class, just suppress these checks.
14595 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Val: CurContext)) {
14596 if (Record->isInvalidDecl()) {
14597 DelayedOverridingExceptionSpecChecks.clear();
14598 DelayedEquivalentExceptionSpecChecks.clear();
14599 return;
14600 }
14601 checkForMultipleExportedDefaultConstructors(S&: *this, Class: Record);
14602 }
14603}
14604
14605void Sema::ActOnFinishCXXNonNestedClass() {
14606 referenceDLLExportedClassMethods();
14607
14608 if (!DelayedDllExportMemberFunctions.empty()) {
14609 SmallVector<CXXMethodDecl*, 4> WorkList;
14610 std::swap(LHS&: DelayedDllExportMemberFunctions, RHS&: WorkList);
14611 for (CXXMethodDecl *M : WorkList) {
14612 DefineDefaultedFunction(S&: *this, FD: M, DefaultLoc: M->getLocation());
14613
14614 // Pass the method to the consumer to get emitted. This is not necessary
14615 // for explicit instantiation definitions, as they will get emitted
14616 // anyway.
14617 if (M->getParent()->getTemplateSpecializationKind() !=
14618 TSK_ExplicitInstantiationDefinition)
14619 ActOnFinishInlineFunctionDef(D: M);
14620 }
14621 }
14622}
14623
14624void Sema::referenceDLLExportedClassMethods() {
14625 if (!DelayedDllExportClasses.empty()) {
14626 // Calling ReferenceDllExportedMembers might cause the current function to
14627 // be called again, so use a local copy of DelayedDllExportClasses.
14628 SmallVector<CXXRecordDecl *, 4> WorkList;
14629 std::swap(LHS&: DelayedDllExportClasses, RHS&: WorkList);
14630 for (CXXRecordDecl *Class : WorkList)
14631 ReferenceDllExportedMembers(S&: *this, Class);
14632 }
14633}
14634
14635void Sema::AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor) {
14636 assert(getLangOpts().CPlusPlus11 &&
14637 "adjusting dtor exception specs was introduced in c++11");
14638
14639 if (Destructor->isDependentContext())
14640 return;
14641
14642 // C++11 [class.dtor]p3:
14643 // A declaration of a destructor that does not have an exception-
14644 // specification is implicitly considered to have the same exception-
14645 // specification as an implicit declaration.
14646 const auto *DtorType = Destructor->getType()->castAs<FunctionProtoType>();
14647 if (DtorType->hasExceptionSpec())
14648 return;
14649
14650 // Replace the destructor's type, building off the existing one. Fortunately,
14651 // the only thing of interest in the destructor type is its extended info.
14652 // The return and arguments are fixed.
14653 FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
14654 EPI.ExceptionSpec.Type = EST_Unevaluated;
14655 EPI.ExceptionSpec.SourceDecl = Destructor;
14656 Destructor->setType(Context.getFunctionType(ResultTy: Context.VoidTy, Args: {}, EPI));
14657
14658 // FIXME: If the destructor has a body that could throw, and the newly created
14659 // spec doesn't allow exceptions, we should emit a warning, because this
14660 // change in behavior can break conforming C++03 programs at runtime.
14661 // However, we don't have a body or an exception specification yet, so it
14662 // needs to be done somewhere else.
14663}
14664
14665namespace {
14666/// An abstract base class for all helper classes used in building the
14667// copy/move operators. These classes serve as factory functions and help us
14668// avoid using the same Expr* in the AST twice.
14669class ExprBuilder {
14670 ExprBuilder(const ExprBuilder&) = delete;
14671 ExprBuilder &operator=(const ExprBuilder&) = delete;
14672
14673protected:
14674 static Expr *assertNotNull(Expr *E) {
14675 assert(E && "Expression construction must not fail.");
14676 return E;
14677 }
14678
14679public:
14680 ExprBuilder() {}
14681 virtual ~ExprBuilder() {}
14682
14683 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
14684};
14685
14686class RefBuilder: public ExprBuilder {
14687 VarDecl *Var;
14688 QualType VarType;
14689
14690public:
14691 Expr *build(Sema &S, SourceLocation Loc) const override {
14692 return assertNotNull(E: S.BuildDeclRefExpr(D: Var, Ty: VarType, VK: VK_LValue, Loc));
14693 }
14694
14695 RefBuilder(VarDecl *Var, QualType VarType)
14696 : Var(Var), VarType(VarType) {}
14697};
14698
14699class ThisBuilder: public ExprBuilder {
14700public:
14701 Expr *build(Sema &S, SourceLocation Loc) const override {
14702 return assertNotNull(E: S.ActOnCXXThis(Loc).getAs<Expr>());
14703 }
14704};
14705
14706class CastBuilder: public ExprBuilder {
14707 const ExprBuilder &Builder;
14708 QualType Type;
14709 ExprValueKind Kind;
14710 const CXXCastPath &Path;
14711
14712public:
14713 Expr *build(Sema &S, SourceLocation Loc) const override {
14714 return assertNotNull(E: S.ImpCastExprToType(E: Builder.build(S, Loc), Type,
14715 CK: CK_UncheckedDerivedToBase, VK: Kind,
14716 BasePath: &Path).get());
14717 }
14718
14719 CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
14720 const CXXCastPath &Path)
14721 : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
14722};
14723
14724class DerefBuilder: public ExprBuilder {
14725 const ExprBuilder &Builder;
14726
14727public:
14728 Expr *build(Sema &S, SourceLocation Loc) const override {
14729 return assertNotNull(
14730 E: S.CreateBuiltinUnaryOp(OpLoc: Loc, Opc: UO_Deref, InputExpr: Builder.build(S, Loc)).get());
14731 }
14732
14733 DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14734};
14735
14736class MemberBuilder: public ExprBuilder {
14737 const ExprBuilder &Builder;
14738 QualType Type;
14739 CXXScopeSpec SS;
14740 bool IsArrow;
14741 LookupResult &MemberLookup;
14742
14743public:
14744 Expr *build(Sema &S, SourceLocation Loc) const override {
14745 return assertNotNull(E: S.BuildMemberReferenceExpr(
14746 Base: Builder.build(S, Loc), BaseType: Type, OpLoc: Loc, IsArrow, SS, TemplateKWLoc: SourceLocation(),
14747 FirstQualifierInScope: nullptr, R&: MemberLookup, TemplateArgs: nullptr, S: nullptr).get());
14748 }
14749
14750 MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
14751 LookupResult &MemberLookup)
14752 : Builder(Builder), Type(Type), IsArrow(IsArrow),
14753 MemberLookup(MemberLookup) {}
14754};
14755
14756class MoveCastBuilder: public ExprBuilder {
14757 const ExprBuilder &Builder;
14758
14759public:
14760 Expr *build(Sema &S, SourceLocation Loc) const override {
14761 return assertNotNull(E: CastForMoving(SemaRef&: S, E: Builder.build(S, Loc)));
14762 }
14763
14764 MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14765};
14766
14767class LvalueConvBuilder: public ExprBuilder {
14768 const ExprBuilder &Builder;
14769
14770public:
14771 Expr *build(Sema &S, SourceLocation Loc) const override {
14772 return assertNotNull(
14773 E: S.DefaultLvalueConversion(E: Builder.build(S, Loc)).get());
14774 }
14775
14776 LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14777};
14778
14779class SubscriptBuilder: public ExprBuilder {
14780 const ExprBuilder &Base;
14781 const ExprBuilder &Index;
14782
14783public:
14784 Expr *build(Sema &S, SourceLocation Loc) const override {
14785 return assertNotNull(E: S.CreateBuiltinArraySubscriptExpr(
14786 Base: Base.build(S, Loc), LLoc: Loc, Idx: Index.build(S, Loc), RLoc: Loc).get());
14787 }
14788
14789 SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
14790 : Base(Base), Index(Index) {}
14791};
14792
14793} // end anonymous namespace
14794
14795/// When generating a defaulted copy or move assignment operator, if a field
14796/// should be copied with __builtin_memcpy rather than via explicit assignments,
14797/// do so. This optimization only applies for arrays of scalars, and for arrays
14798/// of class type where the selected copy/move-assignment operator is trivial.
14799static StmtResult
14800buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T,
14801 const ExprBuilder &ToB, const ExprBuilder &FromB) {
14802 // Compute the size of the memory buffer to be copied.
14803 QualType SizeType = S.Context.getSizeType();
14804 llvm::APInt Size(S.Context.getTypeSize(T: SizeType),
14805 S.Context.getTypeSizeInChars(T).getQuantity());
14806
14807 // Take the address of the field references for "from" and "to". We
14808 // directly construct UnaryOperators here because semantic analysis
14809 // does not permit us to take the address of an xvalue.
14810 Expr *From = FromB.build(S, Loc);
14811 From = UnaryOperator::Create(
14812 C: S.Context, input: From, opc: UO_AddrOf, type: S.Context.getPointerType(T: From->getType()),
14813 VK: VK_PRValue, OK: OK_Ordinary, l: Loc, CanOverflow: false, FPFeatures: S.CurFPFeatureOverrides());
14814 Expr *To = ToB.build(S, Loc);
14815 To = UnaryOperator::Create(
14816 C: S.Context, input: To, opc: UO_AddrOf, type: S.Context.getPointerType(T: To->getType()),
14817 VK: VK_PRValue, OK: OK_Ordinary, l: Loc, CanOverflow: false, FPFeatures: S.CurFPFeatureOverrides());
14818
14819 bool NeedsCollectableMemCpy = false;
14820 if (auto *RD = T->getBaseElementTypeUnsafe()->getAsRecordDecl())
14821 NeedsCollectableMemCpy = RD->hasObjectMember();
14822
14823 // Create a reference to the __builtin_objc_memmove_collectable function
14824 StringRef MemCpyName = NeedsCollectableMemCpy ?
14825 "__builtin_objc_memmove_collectable" :
14826 "__builtin_memcpy";
14827 LookupResult R(S, &S.Context.Idents.get(Name: MemCpyName), Loc,
14828 Sema::LookupOrdinaryName);
14829 S.LookupName(R, S: S.TUScope, AllowBuiltinCreation: true);
14830
14831 FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
14832 if (!MemCpy)
14833 // Something went horribly wrong earlier, and we will have complained
14834 // about it.
14835 return StmtError();
14836
14837 ExprResult MemCpyRef = S.BuildDeclRefExpr(D: MemCpy, Ty: S.Context.BuiltinFnTy,
14838 VK: VK_PRValue, Loc, SS: nullptr);
14839 assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
14840
14841 Expr *CallArgs[] = {
14842 To, From, IntegerLiteral::Create(C: S.Context, V: Size, type: SizeType, l: Loc)
14843 };
14844 ExprResult Call = S.BuildCallExpr(/*Scope=*/S: nullptr, Fn: MemCpyRef.get(),
14845 LParenLoc: Loc, ArgExprs: CallArgs, RParenLoc: Loc);
14846
14847 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
14848 return Call.getAs<Stmt>();
14849}
14850
14851/// Builds a statement that copies/moves the given entity from \p From to
14852/// \c To.
14853///
14854/// This routine is used to copy/move the members of a class with an
14855/// implicitly-declared copy/move assignment operator. When the entities being
14856/// copied are arrays, this routine builds for loops to copy them.
14857///
14858/// \param S The Sema object used for type-checking.
14859///
14860/// \param Loc The location where the implicit copy/move is being generated.
14861///
14862/// \param T The type of the expressions being copied/moved. Both expressions
14863/// must have this type.
14864///
14865/// \param To The expression we are copying/moving to.
14866///
14867/// \param From The expression we are copying/moving from.
14868///
14869/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
14870/// Otherwise, it's a non-static member subobject.
14871///
14872/// \param Copying Whether we're copying or moving.
14873///
14874/// \param Depth Internal parameter recording the depth of the recursion.
14875///
14876/// \returns A statement or a loop that copies the expressions, or StmtResult(0)
14877/// if a memcpy should be used instead.
14878static StmtResult
14879buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
14880 const ExprBuilder &To, const ExprBuilder &From,
14881 bool CopyingBaseSubobject, bool Copying,
14882 unsigned Depth = 0) {
14883 // C++11 [class.copy]p28:
14884 // Each subobject is assigned in the manner appropriate to its type:
14885 //
14886 // - if the subobject is of class type, as if by a call to operator= with
14887 // the subobject as the object expression and the corresponding
14888 // subobject of x as a single function argument (as if by explicit
14889 // qualification; that is, ignoring any possible virtual overriding
14890 // functions in more derived classes);
14891 //
14892 // C++03 [class.copy]p13:
14893 // - if the subobject is of class type, the copy assignment operator for
14894 // the class is used (as if by explicit qualification; that is,
14895 // ignoring any possible virtual overriding functions in more derived
14896 // classes);
14897 if (auto *ClassDecl = T->getAsCXXRecordDecl()) {
14898 // Look for operator=.
14899 DeclarationName Name
14900 = S.Context.DeclarationNames.getCXXOperatorName(Op: OO_Equal);
14901 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
14902 S.LookupQualifiedName(R&: OpLookup, LookupCtx: ClassDecl, InUnqualifiedLookup: false);
14903
14904 // Prior to C++11, filter out any result that isn't a copy/move-assignment
14905 // operator.
14906 if (!S.getLangOpts().CPlusPlus11) {
14907 LookupResult::Filter F = OpLookup.makeFilter();
14908 while (F.hasNext()) {
14909 NamedDecl *D = F.next();
14910 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Val: D))
14911 if (Method->isCopyAssignmentOperator() ||
14912 (!Copying && Method->isMoveAssignmentOperator()))
14913 continue;
14914
14915 F.erase();
14916 }
14917 F.done();
14918 }
14919
14920 // Suppress the protected check (C++ [class.protected]) for each of the
14921 // assignment operators we found. This strange dance is required when
14922 // we're assigning via a base classes's copy-assignment operator. To
14923 // ensure that we're getting the right base class subobject (without
14924 // ambiguities), we need to cast "this" to that subobject type; to
14925 // ensure that we don't go through the virtual call mechanism, we need
14926 // to qualify the operator= name with the base class (see below). However,
14927 // this means that if the base class has a protected copy assignment
14928 // operator, the protected member access check will fail. So, we
14929 // rewrite "protected" access to "public" access in this case, since we
14930 // know by construction that we're calling from a derived class.
14931 if (CopyingBaseSubobject) {
14932 for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
14933 L != LEnd; ++L) {
14934 if (L.getAccess() == AS_protected)
14935 L.setAccess(AS_public);
14936 }
14937 }
14938
14939 // Create the nested-name-specifier that will be used to qualify the
14940 // reference to operator=; this is required to suppress the virtual
14941 // call mechanism.
14942 CXXScopeSpec SS;
14943 // FIXME: Don't canonicalize this.
14944 const Type *CanonicalT = S.Context.getCanonicalType(T: T.getTypePtr());
14945 SS.MakeTrivial(Context&: S.Context, Qualifier: NestedNameSpecifier(CanonicalT), R: Loc);
14946
14947 // Create the reference to operator=.
14948 ExprResult OpEqualRef
14949 = S.BuildMemberReferenceExpr(Base: To.build(S, Loc), BaseType: T, OpLoc: Loc, /*IsArrow=*/false,
14950 SS, /*TemplateKWLoc=*/SourceLocation(),
14951 /*FirstQualifierInScope=*/nullptr,
14952 R&: OpLookup,
14953 /*TemplateArgs=*/nullptr, /*S*/nullptr,
14954 /*SuppressQualifierCheck=*/true);
14955 if (OpEqualRef.isInvalid())
14956 return StmtError();
14957
14958 // Build the call to the assignment operator.
14959
14960 Expr *FromInst = From.build(S, Loc);
14961 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/S: nullptr,
14962 MemExpr: OpEqualRef.getAs<Expr>(),
14963 LParenLoc: Loc, Args: FromInst, RParenLoc: Loc);
14964 if (Call.isInvalid())
14965 return StmtError();
14966
14967 // If we built a call to a trivial 'operator=' while copying an array,
14968 // bail out. We'll replace the whole shebang with a memcpy.
14969 CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Val: Call.get());
14970 if (CE && CE->getMethodDecl()->isTrivial() && Depth)
14971 return StmtResult((Stmt*)nullptr);
14972
14973 // Convert to an expression-statement, and clean up any produced
14974 // temporaries.
14975 return S.ActOnExprStmt(Arg: Call);
14976 }
14977
14978 // - if the subobject is of scalar type, the built-in assignment
14979 // operator is used.
14980 const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
14981 if (!ArrayTy) {
14982 ExprResult Assignment = S.CreateBuiltinBinOp(
14983 OpLoc: Loc, Opc: BO_Assign, LHSExpr: To.build(S, Loc), RHSExpr: From.build(S, Loc));
14984 if (Assignment.isInvalid())
14985 return StmtError();
14986 return S.ActOnExprStmt(Arg: Assignment);
14987 }
14988
14989 // - if the subobject is an array, each element is assigned, in the
14990 // manner appropriate to the element type;
14991
14992 // Construct a loop over the array bounds, e.g.,
14993 //
14994 // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
14995 //
14996 // that will copy each of the array elements.
14997 QualType SizeType = S.Context.getSizeType();
14998
14999 // Create the iteration variable.
15000 IdentifierInfo *IterationVarName = nullptr;
15001 {
15002 SmallString<8> Str;
15003 llvm::raw_svector_ostream OS(Str);
15004 OS << "__i" << Depth;
15005 IterationVarName = &S.Context.Idents.get(Name: OS.str());
15006 }
15007 VarDecl *IterationVar = VarDecl::Create(C&: S.Context, DC: S.CurContext, StartLoc: Loc, IdLoc: Loc,
15008 Id: IterationVarName, T: SizeType,
15009 TInfo: S.Context.getTrivialTypeSourceInfo(T: SizeType, Loc),
15010 S: SC_None);
15011
15012 // Initialize the iteration variable to zero.
15013 llvm::APInt Zero(S.Context.getTypeSize(T: SizeType), 0);
15014 IterationVar->setInit(IntegerLiteral::Create(C: S.Context, V: Zero, type: SizeType, l: Loc));
15015
15016 // Creates a reference to the iteration variable.
15017 RefBuilder IterationVarRef(IterationVar, SizeType);
15018 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
15019
15020 // Create the DeclStmt that holds the iteration variable.
15021 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
15022
15023 // Subscript the "from" and "to" expressions with the iteration variable.
15024 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
15025 MoveCastBuilder FromIndexMove(FromIndexCopy);
15026 const ExprBuilder *FromIndex;
15027 if (Copying)
15028 FromIndex = &FromIndexCopy;
15029 else
15030 FromIndex = &FromIndexMove;
15031
15032 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
15033
15034 // Build the copy/move for an individual element of the array.
15035 StmtResult Copy =
15036 buildSingleCopyAssignRecursively(S, Loc, T: ArrayTy->getElementType(),
15037 To: ToIndex, From: *FromIndex, CopyingBaseSubobject,
15038 Copying, Depth: Depth + 1);
15039 // Bail out if copying fails or if we determined that we should use memcpy.
15040 if (Copy.isInvalid() || !Copy.get())
15041 return Copy;
15042
15043 // Create the comparison against the array bound.
15044 llvm::APInt Upper
15045 = ArrayTy->getSize().zextOrTrunc(width: S.Context.getTypeSize(T: SizeType));
15046 Expr *Comparison = BinaryOperator::Create(
15047 C: S.Context, lhs: IterationVarRefRVal.build(S, Loc),
15048 rhs: IntegerLiteral::Create(C: S.Context, V: Upper, type: SizeType, l: Loc), opc: BO_NE,
15049 ResTy: S.Context.BoolTy, VK: VK_PRValue, OK: OK_Ordinary, opLoc: Loc,
15050 FPFeatures: S.CurFPFeatureOverrides());
15051
15052 // Create the pre-increment of the iteration variable. We can determine
15053 // whether the increment will overflow based on the value of the array
15054 // bound.
15055 Expr *Increment = UnaryOperator::Create(
15056 C: S.Context, input: IterationVarRef.build(S, Loc), opc: UO_PreInc, type: SizeType, VK: VK_LValue,
15057 OK: OK_Ordinary, l: Loc, CanOverflow: Upper.isMaxValue(), FPFeatures: S.CurFPFeatureOverrides());
15058
15059 // Construct the loop that copies all elements of this array.
15060 return S.ActOnForStmt(
15061 ForLoc: Loc, LParenLoc: Loc, First: InitStmt,
15062 Second: S.ActOnCondition(S: nullptr, Loc, SubExpr: Comparison, CK: Sema::ConditionKind::Boolean),
15063 Third: S.MakeFullDiscardedValueExpr(Arg: Increment), RParenLoc: Loc, Body: Copy.get());
15064}
15065
15066static StmtResult
15067buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T,
15068 const ExprBuilder &To, const ExprBuilder &From,
15069 bool CopyingBaseSubobject, bool Copying) {
15070 // Maybe we should use a memcpy?
15071 if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
15072 T.isTriviallyCopyableType(Context: S.Context))
15073 return buildMemcpyForAssignmentOp(S, Loc, T, ToB: To, FromB: From);
15074
15075 StmtResult Result(buildSingleCopyAssignRecursively(S, Loc, T, To, From,
15076 CopyingBaseSubobject,
15077 Copying, Depth: 0));
15078
15079 // If we ended up picking a trivial assignment operator for an array of a
15080 // non-trivially-copyable class type, just emit a memcpy.
15081 if (!Result.isInvalid() && !Result.get())
15082 return buildMemcpyForAssignmentOp(S, Loc, T, ToB: To, FromB: From);
15083
15084 return Result;
15085}
15086
15087CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
15088 // Note: The following rules are largely analoguous to the copy
15089 // constructor rules. Note that virtual bases are not taken into account
15090 // for determining the argument type of the operator. Note also that
15091 // operators taking an object instead of a reference are allowed.
15092 assert(ClassDecl->needsImplicitCopyAssignment());
15093
15094 DeclaringSpecialMember DSM(*this, ClassDecl,
15095 CXXSpecialMemberKind::CopyAssignment);
15096 if (DSM.isAlreadyBeingDeclared())
15097 return nullptr;
15098
15099 QualType ArgType = Context.getTagType(Keyword: ElaboratedTypeKeyword::None,
15100 /*Qualifier=*/std::nullopt, TD: ClassDecl,
15101 /*OwnsTag=*/false);
15102 LangAS AS = getDefaultCXXMethodAddrSpace();
15103 if (AS != LangAS::Default)
15104 ArgType = Context.getAddrSpaceQualType(T: ArgType, AddressSpace: AS);
15105 QualType RetType = Context.getLValueReferenceType(T: ArgType);
15106 bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
15107 if (Const)
15108 ArgType = ArgType.withConst();
15109
15110 ArgType = Context.getLValueReferenceType(T: ArgType);
15111
15112 bool Constexpr = defaultedSpecialMemberIsConstexpr(
15113 S&: *this, ClassDecl, CSM: CXXSpecialMemberKind::CopyAssignment, ConstArg: Const);
15114
15115 // An implicitly-declared copy assignment operator is an inline public
15116 // member of its class.
15117 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(Op: OO_Equal);
15118 SourceLocation ClassLoc = ClassDecl->getLocation();
15119 DeclarationNameInfo NameInfo(Name, ClassLoc);
15120 CXXMethodDecl *CopyAssignment = CXXMethodDecl::Create(
15121 C&: Context, RD: ClassDecl, StartLoc: ClassLoc, NameInfo, T: QualType(),
15122 /*TInfo=*/nullptr, /*StorageClass=*/SC: SC_None,
15123 UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
15124 /*isInline=*/true,
15125 ConstexprKind: Constexpr ? ConstexprSpecKind::Constexpr : ConstexprSpecKind::Unspecified,
15126 EndLocation: SourceLocation());
15127 CopyAssignment->setAccess(AS_public);
15128 CopyAssignment->setDefaulted();
15129 CopyAssignment->setImplicit();
15130
15131 setupImplicitSpecialMemberType(SpecialMem: CopyAssignment, ResultTy: RetType, Args: ArgType);
15132
15133 if (getLangOpts().CUDA)
15134 CUDA().inferTargetForImplicitSpecialMember(
15135 ClassDecl, CSM: CXXSpecialMemberKind::CopyAssignment, MemberDecl: CopyAssignment,
15136 /* ConstRHS */ Const,
15137 /* Diagnose */ false);
15138
15139 // Add the parameter to the operator.
15140 ParmVarDecl *FromParam = ParmVarDecl::Create(C&: Context, DC: CopyAssignment,
15141 StartLoc: ClassLoc, IdLoc: ClassLoc,
15142 /*Id=*/nullptr, T: ArgType,
15143 /*TInfo=*/nullptr, S: SC_None,
15144 DefArg: nullptr);
15145 CopyAssignment->setParams(FromParam);
15146
15147 CopyAssignment->setTrivial(
15148 ClassDecl->needsOverloadResolutionForCopyAssignment()
15149 ? SpecialMemberIsTrivial(MD: CopyAssignment,
15150 CSM: CXXSpecialMemberKind::CopyAssignment)
15151 : ClassDecl->hasTrivialCopyAssignment());
15152
15153 // Note that we have added this copy-assignment operator.
15154 ++getASTContext().NumImplicitCopyAssignmentOperatorsDeclared;
15155
15156 Scope *S = getScopeForContext(Ctx: ClassDecl);
15157 CheckImplicitSpecialMemberDeclaration(S, FD: CopyAssignment);
15158
15159 if (ShouldDeleteSpecialMember(MD: CopyAssignment,
15160 CSM: CXXSpecialMemberKind::CopyAssignment)) {
15161 ClassDecl->setImplicitCopyAssignmentIsDeleted();
15162 SetDeclDeleted(dcl: CopyAssignment, DelLoc: ClassLoc);
15163 }
15164
15165 if (S)
15166 PushOnScopeChains(D: CopyAssignment, S, AddToContext: false);
15167 ClassDecl->addDecl(D: CopyAssignment);
15168
15169 return CopyAssignment;
15170}
15171
15172/// Diagnose an implicit copy operation for a class which is odr-used, but
15173/// which is deprecated because the class has a user-declared copy constructor,
15174/// copy assignment operator, or destructor.
15175static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp) {
15176 assert(CopyOp->isImplicit());
15177
15178 CXXRecordDecl *RD = CopyOp->getParent();
15179 CXXMethodDecl *UserDeclaredOperation = nullptr;
15180
15181 if (RD->hasUserDeclaredDestructor()) {
15182 UserDeclaredOperation = RD->getDestructor();
15183 } else if (!isa<CXXConstructorDecl>(Val: CopyOp) &&
15184 RD->hasUserDeclaredCopyConstructor()) {
15185 // Find any user-declared copy constructor.
15186 for (auto *I : RD->ctors()) {
15187 if (I->isCopyConstructor()) {
15188 UserDeclaredOperation = I;
15189 break;
15190 }
15191 }
15192 assert(UserDeclaredOperation);
15193 } else if (isa<CXXConstructorDecl>(Val: CopyOp) &&
15194 RD->hasUserDeclaredCopyAssignment()) {
15195 // Find any user-declared move assignment operator.
15196 for (auto *I : RD->methods()) {
15197 if (I->isCopyAssignmentOperator()) {
15198 UserDeclaredOperation = I;
15199 break;
15200 }
15201 }
15202 assert(UserDeclaredOperation);
15203 }
15204
15205 if (UserDeclaredOperation) {
15206 bool UDOIsUserProvided = UserDeclaredOperation->isUserProvided();
15207 bool UDOIsDestructor = isa<CXXDestructorDecl>(Val: UserDeclaredOperation);
15208 bool IsCopyAssignment = !isa<CXXConstructorDecl>(Val: CopyOp);
15209 unsigned DiagID =
15210 (UDOIsUserProvided && UDOIsDestructor)
15211 ? diag::warn_deprecated_copy_with_user_provided_dtor
15212 : (UDOIsUserProvided && !UDOIsDestructor)
15213 ? diag::warn_deprecated_copy_with_user_provided_copy
15214 : (!UDOIsUserProvided && UDOIsDestructor)
15215 ? diag::warn_deprecated_copy_with_dtor
15216 : diag::warn_deprecated_copy;
15217 S.Diag(Loc: UserDeclaredOperation->getLocation(), DiagID)
15218 << RD << IsCopyAssignment;
15219 }
15220}
15221
15222void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
15223 CXXMethodDecl *CopyAssignOperator) {
15224 assert((CopyAssignOperator->isDefaulted() &&
15225 CopyAssignOperator->isOverloadedOperator() &&
15226 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
15227 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
15228 !CopyAssignOperator->isDeleted()) &&
15229 "DefineImplicitCopyAssignment called for wrong function");
15230 if (CopyAssignOperator->willHaveBody() || CopyAssignOperator->isInvalidDecl())
15231 return;
15232
15233 CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
15234 if (ClassDecl->isInvalidDecl()) {
15235 CopyAssignOperator->setInvalidDecl();
15236 return;
15237 }
15238
15239 SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
15240
15241 // The exception specification is needed because we are defining the
15242 // function.
15243 ResolveExceptionSpec(Loc: CurrentLocation,
15244 FPT: CopyAssignOperator->getType()->castAs<FunctionProtoType>());
15245
15246 // Add a context note for diagnostics produced after this point.
15247 Scope.addContextNote(UseLoc: CurrentLocation);
15248
15249 // C++11 [class.copy]p18:
15250 // The [definition of an implicitly declared copy assignment operator] is
15251 // deprecated if the class has a user-declared copy constructor or a
15252 // user-declared destructor.
15253 if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
15254 diagnoseDeprecatedCopyOperation(S&: *this, CopyOp: CopyAssignOperator);
15255
15256 // C++0x [class.copy]p30:
15257 // The implicitly-defined or explicitly-defaulted copy assignment operator
15258 // for a non-union class X performs memberwise copy assignment of its
15259 // subobjects. The direct base classes of X are assigned first, in the
15260 // order of their declaration in the base-specifier-list, and then the
15261 // immediate non-static data members of X are assigned, in the order in
15262 // which they were declared in the class definition.
15263
15264 // The statements that form the synthesized function body.
15265 SmallVector<Stmt*, 8> Statements;
15266
15267 // The parameter for the "other" object, which we are copying from.
15268 ParmVarDecl *Other = CopyAssignOperator->getNonObjectParameter(I: 0);
15269 Qualifiers OtherQuals = Other->getType().getQualifiers();
15270 QualType OtherRefType = Other->getType();
15271 if (OtherRefType->isLValueReferenceType()) {
15272 OtherRefType = OtherRefType->getPointeeType();
15273 OtherQuals = OtherRefType.getQualifiers();
15274 }
15275
15276 // Our location for everything implicitly-generated.
15277 SourceLocation Loc = CopyAssignOperator->getEndLoc().isValid()
15278 ? CopyAssignOperator->getEndLoc()
15279 : CopyAssignOperator->getLocation();
15280
15281 // Builds a DeclRefExpr for the "other" object.
15282 RefBuilder OtherRef(Other, OtherRefType);
15283
15284 // Builds the function object parameter.
15285 std::optional<ThisBuilder> This;
15286 std::optional<DerefBuilder> DerefThis;
15287 std::optional<RefBuilder> ExplicitObject;
15288 bool IsArrow = false;
15289 QualType ObjectType;
15290 if (CopyAssignOperator->isExplicitObjectMemberFunction()) {
15291 ObjectType = CopyAssignOperator->getParamDecl(i: 0)->getType();
15292 if (ObjectType->isReferenceType())
15293 ObjectType = ObjectType->getPointeeType();
15294 ExplicitObject.emplace(args: CopyAssignOperator->getParamDecl(i: 0), args&: ObjectType);
15295 } else {
15296 ObjectType = getCurrentThisType();
15297 This.emplace();
15298 DerefThis.emplace(args&: *This);
15299 IsArrow = !LangOpts.HLSL;
15300 }
15301 ExprBuilder &ObjectParameter =
15302 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15303 : static_cast<ExprBuilder &>(*This);
15304
15305 // Assign base classes.
15306 bool Invalid = false;
15307 for (auto &Base : ClassDecl->bases()) {
15308 // Form the assignment:
15309 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
15310 QualType BaseType = Base.getType().getUnqualifiedType();
15311 if (!BaseType->isRecordType()) {
15312 Invalid = true;
15313 continue;
15314 }
15315
15316 CXXCastPath BasePath;
15317 BasePath.push_back(Elt: &Base);
15318
15319 // Construct the "from" expression, which is an implicit cast to the
15320 // appropriately-qualified base type.
15321 CastBuilder From(OtherRef, Context.getQualifiedType(T: BaseType, Qs: OtherQuals),
15322 VK_LValue, BasePath);
15323
15324 // Dereference "this".
15325 CastBuilder To(
15326 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15327 : static_cast<ExprBuilder &>(*DerefThis),
15328 Context.getQualifiedType(T: BaseType, Qs: ObjectType.getQualifiers()),
15329 VK_LValue, BasePath);
15330
15331 // Build the copy.
15332 StmtResult Copy = buildSingleCopyAssign(S&: *this, Loc, T: BaseType,
15333 To, From,
15334 /*CopyingBaseSubobject=*/true,
15335 /*Copying=*/true);
15336 if (Copy.isInvalid()) {
15337 CopyAssignOperator->setInvalidDecl();
15338 return;
15339 }
15340
15341 // Success! Record the copy.
15342 Statements.push_back(Elt: Copy.getAs<Expr>());
15343 }
15344
15345 // Assign non-static members.
15346 for (auto *Field : ClassDecl->fields()) {
15347 // FIXME: We should form some kind of AST representation for the implied
15348 // memcpy in a union copy operation.
15349 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15350 continue;
15351
15352 if (Field->isInvalidDecl()) {
15353 Invalid = true;
15354 continue;
15355 }
15356
15357 // Check for members of reference type; we can't copy those.
15358 if (Field->getType()->isReferenceType()) {
15359 Diag(Loc: ClassDecl->getLocation(), DiagID: diag::err_uninitialized_member_for_assign)
15360 << Context.getCanonicalTagType(TD: ClassDecl) << 0
15361 << Field->getDeclName();
15362 Diag(Loc: Field->getLocation(), DiagID: diag::note_declared_at);
15363 Invalid = true;
15364 continue;
15365 }
15366
15367 // Check for members of const-qualified, non-class type.
15368 QualType BaseType = Context.getBaseElementType(QT: Field->getType());
15369 if (!BaseType->isRecordType() && BaseType.isConstQualified()) {
15370 Diag(Loc: ClassDecl->getLocation(), DiagID: diag::err_uninitialized_member_for_assign)
15371 << Context.getCanonicalTagType(TD: ClassDecl) << 1
15372 << Field->getDeclName();
15373 Diag(Loc: Field->getLocation(), DiagID: diag::note_declared_at);
15374 Invalid = true;
15375 continue;
15376 }
15377
15378 // Suppress assigning zero-width bitfields.
15379 if (Field->isZeroLengthBitField())
15380 continue;
15381
15382 QualType FieldType = Field->getType().getNonReferenceType();
15383 if (FieldType->isIncompleteArrayType()) {
15384 assert(ClassDecl->hasFlexibleArrayMember() &&
15385 "Incomplete array type is not valid");
15386 continue;
15387 }
15388
15389 // Build references to the field in the object we're copying from and to.
15390 CXXScopeSpec SS; // Intentionally empty
15391 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
15392 LookupMemberName);
15393 MemberLookup.addDecl(D: Field);
15394 MemberLookup.resolveKind();
15395
15396 MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
15397 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15398 // Build the copy of this field.
15399 StmtResult Copy = buildSingleCopyAssign(S&: *this, Loc, T: FieldType,
15400 To, From,
15401 /*CopyingBaseSubobject=*/false,
15402 /*Copying=*/true);
15403 if (Copy.isInvalid()) {
15404 CopyAssignOperator->setInvalidDecl();
15405 return;
15406 }
15407
15408 // Success! Record the copy.
15409 Statements.push_back(Elt: Copy.getAs<Stmt>());
15410 }
15411
15412 if (!Invalid) {
15413 // Add a "return *this;"
15414 Expr *ThisExpr =
15415 (ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15416 : LangOpts.HLSL ? static_cast<ExprBuilder &>(*This)
15417 : static_cast<ExprBuilder &>(*DerefThis))
15418 .build(S&: *this, Loc);
15419 StmtResult Return = BuildReturnStmt(ReturnLoc: Loc, RetValExp: ThisExpr);
15420 if (Return.isInvalid())
15421 Invalid = true;
15422 else
15423 Statements.push_back(Elt: Return.getAs<Stmt>());
15424 }
15425
15426 if (Invalid) {
15427 CopyAssignOperator->setInvalidDecl();
15428 return;
15429 }
15430
15431 StmtResult Body;
15432 {
15433 CompoundScopeRAII CompoundScope(*this);
15434 Body = ActOnCompoundStmt(L: Loc, R: Loc, Elts: Statements,
15435 /*isStmtExpr=*/false);
15436 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
15437 }
15438 CopyAssignOperator->setBody(Body.getAs<Stmt>());
15439 CopyAssignOperator->markUsed(C&: Context);
15440
15441 if (ASTMutationListener *L = getASTMutationListener()) {
15442 L->CompletedImplicitDefinition(D: CopyAssignOperator);
15443 }
15444}
15445
15446CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
15447 assert(ClassDecl->needsImplicitMoveAssignment());
15448
15449 DeclaringSpecialMember DSM(*this, ClassDecl,
15450 CXXSpecialMemberKind::MoveAssignment);
15451 if (DSM.isAlreadyBeingDeclared())
15452 return nullptr;
15453
15454 // Note: The following rules are largely analoguous to the move
15455 // constructor rules.
15456
15457 QualType ArgType = Context.getTagType(Keyword: ElaboratedTypeKeyword::None,
15458 /*Qualifier=*/std::nullopt, TD: ClassDecl,
15459 /*OwnsTag=*/false);
15460 LangAS AS = getDefaultCXXMethodAddrSpace();
15461 if (AS != LangAS::Default)
15462 ArgType = Context.getAddrSpaceQualType(T: ArgType, AddressSpace: AS);
15463 QualType RetType = Context.getLValueReferenceType(T: ArgType);
15464 ArgType = Context.getRValueReferenceType(T: ArgType);
15465
15466 bool Constexpr = defaultedSpecialMemberIsConstexpr(
15467 S&: *this, ClassDecl, CSM: CXXSpecialMemberKind::MoveAssignment, ConstArg: false);
15468
15469 // An implicitly-declared move assignment operator is an inline public
15470 // member of its class.
15471 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(Op: OO_Equal);
15472 SourceLocation ClassLoc = ClassDecl->getLocation();
15473 DeclarationNameInfo NameInfo(Name, ClassLoc);
15474 CXXMethodDecl *MoveAssignment = CXXMethodDecl::Create(
15475 C&: Context, RD: ClassDecl, StartLoc: ClassLoc, NameInfo, T: QualType(),
15476 /*TInfo=*/nullptr, /*StorageClass=*/SC: SC_None,
15477 UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
15478 /*isInline=*/true,
15479 ConstexprKind: Constexpr ? ConstexprSpecKind::Constexpr : ConstexprSpecKind::Unspecified,
15480 EndLocation: SourceLocation());
15481 MoveAssignment->setAccess(AS_public);
15482 MoveAssignment->setDefaulted();
15483 MoveAssignment->setImplicit();
15484
15485 setupImplicitSpecialMemberType(SpecialMem: MoveAssignment, ResultTy: RetType, Args: ArgType);
15486
15487 if (getLangOpts().CUDA)
15488 CUDA().inferTargetForImplicitSpecialMember(
15489 ClassDecl, CSM: CXXSpecialMemberKind::MoveAssignment, MemberDecl: MoveAssignment,
15490 /* ConstRHS */ false,
15491 /* Diagnose */ false);
15492
15493 // Add the parameter to the operator.
15494 ParmVarDecl *FromParam = ParmVarDecl::Create(C&: Context, DC: MoveAssignment,
15495 StartLoc: ClassLoc, IdLoc: ClassLoc,
15496 /*Id=*/nullptr, T: ArgType,
15497 /*TInfo=*/nullptr, S: SC_None,
15498 DefArg: nullptr);
15499 MoveAssignment->setParams(FromParam);
15500
15501 MoveAssignment->setTrivial(
15502 ClassDecl->needsOverloadResolutionForMoveAssignment()
15503 ? SpecialMemberIsTrivial(MD: MoveAssignment,
15504 CSM: CXXSpecialMemberKind::MoveAssignment)
15505 : ClassDecl->hasTrivialMoveAssignment());
15506
15507 // Note that we have added this copy-assignment operator.
15508 ++getASTContext().NumImplicitMoveAssignmentOperatorsDeclared;
15509
15510 Scope *S = getScopeForContext(Ctx: ClassDecl);
15511 CheckImplicitSpecialMemberDeclaration(S, FD: MoveAssignment);
15512
15513 if (ShouldDeleteSpecialMember(MD: MoveAssignment,
15514 CSM: CXXSpecialMemberKind::MoveAssignment)) {
15515 ClassDecl->setImplicitMoveAssignmentIsDeleted();
15516 SetDeclDeleted(dcl: MoveAssignment, DelLoc: ClassLoc);
15517 }
15518
15519 if (S)
15520 PushOnScopeChains(D: MoveAssignment, S, AddToContext: false);
15521 ClassDecl->addDecl(D: MoveAssignment);
15522
15523 return MoveAssignment;
15524}
15525
15526/// Check if we're implicitly defining a move assignment operator for a class
15527/// with virtual bases. Such a move assignment might move-assign the virtual
15528/// base multiple times.
15529static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class,
15530 SourceLocation CurrentLocation) {
15531 assert(!Class->isDependentContext() && "should not define dependent move");
15532
15533 // Only a virtual base could get implicitly move-assigned multiple times.
15534 // Only a non-trivial move assignment can observe this. We only want to
15535 // diagnose if we implicitly define an assignment operator that assigns
15536 // two base classes, both of which move-assign the same virtual base.
15537 if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
15538 Class->getNumBases() < 2)
15539 return;
15540
15541 llvm::SmallVector<CXXBaseSpecifier *, 16> Worklist;
15542 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15543 VBaseMap VBases;
15544
15545 for (auto &BI : Class->bases()) {
15546 Worklist.push_back(Elt: &BI);
15547 while (!Worklist.empty()) {
15548 CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
15549 CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
15550
15551 // If the base has no non-trivial move assignment operators,
15552 // we don't care about moves from it.
15553 if (!Base->hasNonTrivialMoveAssignment())
15554 continue;
15555
15556 // If there's nothing virtual here, skip it.
15557 if (!BaseSpec->isVirtual() && !Base->getNumVBases())
15558 continue;
15559
15560 // If we're not actually going to call a move assignment for this base,
15561 // or the selected move assignment is trivial, skip it.
15562 Sema::SpecialMemberOverloadResult SMOR =
15563 S.LookupSpecialMember(D: Base, SM: CXXSpecialMemberKind::MoveAssignment,
15564 /*ConstArg*/ false, /*VolatileArg*/ false,
15565 /*RValueThis*/ true, /*ConstThis*/ false,
15566 /*VolatileThis*/ false);
15567 if (!SMOR.getMethod() || SMOR.getMethod()->isTrivial() ||
15568 !SMOR.getMethod()->isMoveAssignmentOperator())
15569 continue;
15570
15571 if (BaseSpec->isVirtual()) {
15572 // We're going to move-assign this virtual base, and its move
15573 // assignment operator is not trivial. If this can happen for
15574 // multiple distinct direct bases of Class, diagnose it. (If it
15575 // only happens in one base, we'll diagnose it when synthesizing
15576 // that base class's move assignment operator.)
15577 CXXBaseSpecifier *&Existing =
15578 VBases.insert(KV: std::make_pair(x: Base->getCanonicalDecl(), y: &BI))
15579 .first->second;
15580 if (Existing && Existing != &BI) {
15581 S.Diag(Loc: CurrentLocation, DiagID: diag::warn_vbase_moved_multiple_times)
15582 << Class << Base;
15583 S.Diag(Loc: Existing->getBeginLoc(), DiagID: diag::note_vbase_moved_here)
15584 << (Base->getCanonicalDecl() ==
15585 Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15586 << Base << Existing->getType() << Existing->getSourceRange();
15587 S.Diag(Loc: BI.getBeginLoc(), DiagID: diag::note_vbase_moved_here)
15588 << (Base->getCanonicalDecl() ==
15589 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15590 << Base << BI.getType() << BaseSpec->getSourceRange();
15591
15592 // Only diagnose each vbase once.
15593 Existing = nullptr;
15594 }
15595 } else {
15596 // Only walk over bases that have defaulted move assignment operators.
15597 // We assume that any user-provided move assignment operator handles
15598 // the multiple-moves-of-vbase case itself somehow.
15599 if (!SMOR.getMethod()->isDefaulted())
15600 continue;
15601
15602 // We're going to move the base classes of Base. Add them to the list.
15603 llvm::append_range(C&: Worklist, R: llvm::make_pointer_range(Range: Base->bases()));
15604 }
15605 }
15606 }
15607}
15608
15609void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
15610 CXXMethodDecl *MoveAssignOperator) {
15611 assert((MoveAssignOperator->isDefaulted() &&
15612 MoveAssignOperator->isOverloadedOperator() &&
15613 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
15614 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
15615 !MoveAssignOperator->isDeleted()) &&
15616 "DefineImplicitMoveAssignment called for wrong function");
15617 if (MoveAssignOperator->willHaveBody() || MoveAssignOperator->isInvalidDecl())
15618 return;
15619
15620 CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
15621 if (ClassDecl->isInvalidDecl()) {
15622 MoveAssignOperator->setInvalidDecl();
15623 return;
15624 }
15625
15626 // C++0x [class.copy]p28:
15627 // The implicitly-defined or move assignment operator for a non-union class
15628 // X performs memberwise move assignment of its subobjects. The direct base
15629 // classes of X are assigned first, in the order of their declaration in the
15630 // base-specifier-list, and then the immediate non-static data members of X
15631 // are assigned, in the order in which they were declared in the class
15632 // definition.
15633
15634 // Issue a warning if our implicit move assignment operator will move
15635 // from a virtual base more than once.
15636 checkMoveAssignmentForRepeatedMove(S&: *this, Class: ClassDecl, CurrentLocation);
15637
15638 SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
15639
15640 // The exception specification is needed because we are defining the
15641 // function.
15642 ResolveExceptionSpec(Loc: CurrentLocation,
15643 FPT: MoveAssignOperator->getType()->castAs<FunctionProtoType>());
15644
15645 // Add a context note for diagnostics produced after this point.
15646 Scope.addContextNote(UseLoc: CurrentLocation);
15647
15648 // The statements that form the synthesized function body.
15649 SmallVector<Stmt*, 8> Statements;
15650
15651 // The parameter for the "other" object, which we are move from.
15652 ParmVarDecl *Other = MoveAssignOperator->getNonObjectParameter(I: 0);
15653 QualType OtherRefType =
15654 Other->getType()->castAs<RValueReferenceType>()->getPointeeType();
15655
15656 // Our location for everything implicitly-generated.
15657 SourceLocation Loc = MoveAssignOperator->getEndLoc().isValid()
15658 ? MoveAssignOperator->getEndLoc()
15659 : MoveAssignOperator->getLocation();
15660
15661 // Builds a reference to the "other" object.
15662 RefBuilder OtherRef(Other, OtherRefType);
15663 // Cast to rvalue.
15664 MoveCastBuilder MoveOther(OtherRef);
15665
15666 // Builds the function object parameter.
15667 std::optional<ThisBuilder> This;
15668 std::optional<DerefBuilder> DerefThis;
15669 std::optional<RefBuilder> ExplicitObject;
15670 QualType ObjectType;
15671 bool IsArrow = false;
15672 if (MoveAssignOperator->isExplicitObjectMemberFunction()) {
15673 ObjectType = MoveAssignOperator->getParamDecl(i: 0)->getType();
15674 if (ObjectType->isReferenceType())
15675 ObjectType = ObjectType->getPointeeType();
15676 ExplicitObject.emplace(args: MoveAssignOperator->getParamDecl(i: 0), args&: ObjectType);
15677 } else {
15678 ObjectType = getCurrentThisType();
15679 This.emplace();
15680 DerefThis.emplace(args&: *This);
15681 IsArrow = !getLangOpts().HLSL;
15682 }
15683 ExprBuilder &ObjectParameter =
15684 ExplicitObject ? *ExplicitObject : static_cast<ExprBuilder &>(*This);
15685
15686 // Assign base classes.
15687 bool Invalid = false;
15688 for (auto &Base : ClassDecl->bases()) {
15689 // C++11 [class.copy]p28:
15690 // It is unspecified whether subobjects representing virtual base classes
15691 // are assigned more than once by the implicitly-defined copy assignment
15692 // operator.
15693 // FIXME: Do not assign to a vbase that will be assigned by some other base
15694 // class. For a move-assignment, this can result in the vbase being moved
15695 // multiple times.
15696
15697 // Form the assignment:
15698 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
15699 QualType BaseType = Base.getType().getUnqualifiedType();
15700 if (!BaseType->isRecordType()) {
15701 Invalid = true;
15702 continue;
15703 }
15704
15705 CXXCastPath BasePath;
15706 BasePath.push_back(Elt: &Base);
15707
15708 // Construct the "from" expression, which is an implicit cast to the
15709 // appropriately-qualified base type.
15710 CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
15711
15712 // Implicitly cast "this" to the appropriately-qualified base type.
15713 // Dereference "this".
15714 CastBuilder To(
15715 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15716 : static_cast<ExprBuilder &>(*DerefThis),
15717 Context.getQualifiedType(T: BaseType, Qs: ObjectType.getQualifiers()),
15718 VK_LValue, BasePath);
15719
15720 // Build the move.
15721 StmtResult Move = buildSingleCopyAssign(S&: *this, Loc, T: BaseType,
15722 To, From,
15723 /*CopyingBaseSubobject=*/true,
15724 /*Copying=*/false);
15725 if (Move.isInvalid()) {
15726 MoveAssignOperator->setInvalidDecl();
15727 return;
15728 }
15729
15730 // Success! Record the move.
15731 Statements.push_back(Elt: Move.getAs<Expr>());
15732 }
15733
15734 // Assign non-static members.
15735 for (auto *Field : ClassDecl->fields()) {
15736 // FIXME: We should form some kind of AST representation for the implied
15737 // memcpy in a union copy operation.
15738 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15739 continue;
15740
15741 if (Field->isInvalidDecl()) {
15742 Invalid = true;
15743 continue;
15744 }
15745
15746 // Check for members of reference type; we can't move those.
15747 if (Field->getType()->isReferenceType()) {
15748 Diag(Loc: ClassDecl->getLocation(), DiagID: diag::err_uninitialized_member_for_assign)
15749 << Context.getCanonicalTagType(TD: ClassDecl) << 0
15750 << Field->getDeclName();
15751 Diag(Loc: Field->getLocation(), DiagID: diag::note_declared_at);
15752 Invalid = true;
15753 continue;
15754 }
15755
15756 // Check for members of const-qualified, non-class type.
15757 QualType BaseType = Context.getBaseElementType(QT: Field->getType());
15758 if (!BaseType->isRecordType() && BaseType.isConstQualified()) {
15759 Diag(Loc: ClassDecl->getLocation(), DiagID: diag::err_uninitialized_member_for_assign)
15760 << Context.getCanonicalTagType(TD: ClassDecl) << 1
15761 << Field->getDeclName();
15762 Diag(Loc: Field->getLocation(), DiagID: diag::note_declared_at);
15763 Invalid = true;
15764 continue;
15765 }
15766
15767 // Suppress assigning zero-width bitfields.
15768 if (Field->isZeroLengthBitField())
15769 continue;
15770
15771 QualType FieldType = Field->getType().getNonReferenceType();
15772 if (FieldType->isIncompleteArrayType()) {
15773 assert(ClassDecl->hasFlexibleArrayMember() &&
15774 "Incomplete array type is not valid");
15775 continue;
15776 }
15777
15778 // Build references to the field in the object we're copying from and to.
15779 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
15780 LookupMemberName);
15781 MemberLookup.addDecl(D: Field);
15782 MemberLookup.resolveKind();
15783 MemberBuilder From(MoveOther, OtherRefType,
15784 /*IsArrow=*/false, MemberLookup);
15785 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15786
15787 assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
15788 "Member reference with rvalue base must be rvalue except for reference "
15789 "members, which aren't allowed for move assignment.");
15790
15791 // Build the move of this field.
15792 StmtResult Move = buildSingleCopyAssign(S&: *this, Loc, T: FieldType,
15793 To, From,
15794 /*CopyingBaseSubobject=*/false,
15795 /*Copying=*/false);
15796 if (Move.isInvalid()) {
15797 MoveAssignOperator->setInvalidDecl();
15798 return;
15799 }
15800
15801 // Success! Record the copy.
15802 Statements.push_back(Elt: Move.getAs<Stmt>());
15803 }
15804
15805 if (!Invalid) {
15806 // Add a "return *this;"
15807 Expr *ThisExpr =
15808 (ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15809 : LangOpts.HLSL ? static_cast<ExprBuilder &>(*This)
15810 : static_cast<ExprBuilder &>(*DerefThis))
15811 .build(S&: *this, Loc);
15812
15813 StmtResult Return = BuildReturnStmt(ReturnLoc: Loc, RetValExp: ThisExpr);
15814 if (Return.isInvalid())
15815 Invalid = true;
15816 else
15817 Statements.push_back(Elt: Return.getAs<Stmt>());
15818 }
15819
15820 if (Invalid) {
15821 MoveAssignOperator->setInvalidDecl();
15822 return;
15823 }
15824
15825 StmtResult Body;
15826 {
15827 CompoundScopeRAII CompoundScope(*this);
15828 Body = ActOnCompoundStmt(L: Loc, R: Loc, Elts: Statements,
15829 /*isStmtExpr=*/false);
15830 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
15831 }
15832 MoveAssignOperator->setBody(Body.getAs<Stmt>());
15833 MoveAssignOperator->markUsed(C&: Context);
15834
15835 if (ASTMutationListener *L = getASTMutationListener()) {
15836 L->CompletedImplicitDefinition(D: MoveAssignOperator);
15837 }
15838}
15839
15840CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
15841 CXXRecordDecl *ClassDecl) {
15842 // C++ [class.copy]p4:
15843 // If the class definition does not explicitly declare a copy
15844 // constructor, one is declared implicitly.
15845 assert(ClassDecl->needsImplicitCopyConstructor());
15846
15847 DeclaringSpecialMember DSM(*this, ClassDecl,
15848 CXXSpecialMemberKind::CopyConstructor);
15849 if (DSM.isAlreadyBeingDeclared())
15850 return nullptr;
15851
15852 QualType ClassType = Context.getTagType(Keyword: ElaboratedTypeKeyword::None,
15853 /*Qualifier=*/std::nullopt, TD: ClassDecl,
15854 /*OwnsTag=*/false);
15855 QualType ArgType = ClassType;
15856 bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
15857 if (Const)
15858 ArgType = ArgType.withConst();
15859
15860 LangAS AS = getDefaultCXXMethodAddrSpace();
15861 if (AS != LangAS::Default)
15862 ArgType = Context.getAddrSpaceQualType(T: ArgType, AddressSpace: AS);
15863
15864 ArgType = Context.getLValueReferenceType(T: ArgType);
15865
15866 bool Constexpr = defaultedSpecialMemberIsConstexpr(
15867 S&: *this, ClassDecl, CSM: CXXSpecialMemberKind::CopyConstructor, ConstArg: Const);
15868
15869 DeclarationName Name
15870 = Context.DeclarationNames.getCXXConstructorName(
15871 Ty: Context.getCanonicalType(T: ClassType));
15872 SourceLocation ClassLoc = ClassDecl->getLocation();
15873 DeclarationNameInfo NameInfo(Name, ClassLoc);
15874
15875 // An implicitly-declared copy constructor is an inline public
15876 // member of its class.
15877 CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
15878 C&: Context, RD: ClassDecl, StartLoc: ClassLoc, NameInfo, T: QualType(), /*TInfo=*/nullptr,
15879 ES: ExplicitSpecifier(), UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
15880 /*isInline=*/true,
15881 /*isImplicitlyDeclared=*/true,
15882 ConstexprKind: Constexpr ? ConstexprSpecKind::Constexpr
15883 : ConstexprSpecKind::Unspecified);
15884 CopyConstructor->setAccess(AS_public);
15885 CopyConstructor->setDefaulted();
15886
15887 setupImplicitSpecialMemberType(SpecialMem: CopyConstructor, ResultTy: Context.VoidTy, Args: ArgType);
15888
15889 if (getLangOpts().CUDA)
15890 CUDA().inferTargetForImplicitSpecialMember(
15891 ClassDecl, CSM: CXXSpecialMemberKind::CopyConstructor, MemberDecl: CopyConstructor,
15892 /* ConstRHS */ Const,
15893 /* Diagnose */ false);
15894
15895 // During template instantiation of special member functions we need a
15896 // reliable TypeSourceInfo for the parameter types in order to allow functions
15897 // to be substituted.
15898 TypeSourceInfo *TSI = nullptr;
15899 if (inTemplateInstantiation() && ClassDecl->isLambda())
15900 TSI = Context.getTrivialTypeSourceInfo(T: ArgType);
15901
15902 // Add the parameter to the constructor.
15903 ParmVarDecl *FromParam =
15904 ParmVarDecl::Create(C&: Context, DC: CopyConstructor, StartLoc: ClassLoc, IdLoc: ClassLoc,
15905 /*IdentifierInfo=*/Id: nullptr, T: ArgType,
15906 /*TInfo=*/TSI, S: SC_None, DefArg: nullptr);
15907 CopyConstructor->setParams(FromParam);
15908
15909 CopyConstructor->setTrivial(
15910 ClassDecl->needsOverloadResolutionForCopyConstructor()
15911 ? SpecialMemberIsTrivial(MD: CopyConstructor,
15912 CSM: CXXSpecialMemberKind::CopyConstructor)
15913 : ClassDecl->hasTrivialCopyConstructor());
15914
15915 CopyConstructor->setTrivialForCall(
15916 ClassDecl->hasAttr<TrivialABIAttr>() ||
15917 (ClassDecl->needsOverloadResolutionForCopyConstructor()
15918 ? SpecialMemberIsTrivial(MD: CopyConstructor,
15919 CSM: CXXSpecialMemberKind::CopyConstructor,
15920 TAH: TrivialABIHandling::ConsiderTrivialABI)
15921 : ClassDecl->hasTrivialCopyConstructorForCall()));
15922
15923 // Note that we have declared this constructor.
15924 ++getASTContext().NumImplicitCopyConstructorsDeclared;
15925
15926 Scope *S = getScopeForContext(Ctx: ClassDecl);
15927 CheckImplicitSpecialMemberDeclaration(S, FD: CopyConstructor);
15928
15929 if (ShouldDeleteSpecialMember(MD: CopyConstructor,
15930 CSM: CXXSpecialMemberKind::CopyConstructor)) {
15931 ClassDecl->setImplicitCopyConstructorIsDeleted();
15932 SetDeclDeleted(dcl: CopyConstructor, DelLoc: ClassLoc);
15933 }
15934
15935 if (S)
15936 PushOnScopeChains(D: CopyConstructor, S, AddToContext: false);
15937 ClassDecl->addDecl(D: CopyConstructor);
15938
15939 return CopyConstructor;
15940}
15941
15942void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
15943 CXXConstructorDecl *CopyConstructor) {
15944 assert((CopyConstructor->isDefaulted() &&
15945 CopyConstructor->isCopyConstructor() &&
15946 !CopyConstructor->doesThisDeclarationHaveABody() &&
15947 !CopyConstructor->isDeleted()) &&
15948 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
15949 if (CopyConstructor->willHaveBody() || CopyConstructor->isInvalidDecl())
15950 return;
15951
15952 CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
15953 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
15954
15955 SynthesizedFunctionScope Scope(*this, CopyConstructor);
15956
15957 // The exception specification is needed because we are defining the
15958 // function.
15959 ResolveExceptionSpec(Loc: CurrentLocation,
15960 FPT: CopyConstructor->getType()->castAs<FunctionProtoType>());
15961 MarkVTableUsed(Loc: CurrentLocation, Class: ClassDecl);
15962
15963 // Add a context note for diagnostics produced after this point.
15964 Scope.addContextNote(UseLoc: CurrentLocation);
15965
15966 // C++11 [class.copy]p7:
15967 // The [definition of an implicitly declared copy constructor] is
15968 // deprecated if the class has a user-declared copy assignment operator
15969 // or a user-declared destructor.
15970 if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
15971 diagnoseDeprecatedCopyOperation(S&: *this, CopyOp: CopyConstructor);
15972
15973 if (SetCtorInitializers(Constructor: CopyConstructor, /*AnyErrors=*/false)) {
15974 CopyConstructor->setInvalidDecl();
15975 } else {
15976 SourceLocation Loc = CopyConstructor->getEndLoc().isValid()
15977 ? CopyConstructor->getEndLoc()
15978 : CopyConstructor->getLocation();
15979 Sema::CompoundScopeRAII CompoundScope(*this);
15980 CopyConstructor->setBody(
15981 ActOnCompoundStmt(L: Loc, R: Loc, Elts: {}, /*isStmtExpr=*/false).getAs<Stmt>());
15982 CopyConstructor->markUsed(C&: Context);
15983 }
15984
15985 if (ASTMutationListener *L = getASTMutationListener()) {
15986 L->CompletedImplicitDefinition(D: CopyConstructor);
15987 }
15988}
15989
15990CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
15991 CXXRecordDecl *ClassDecl) {
15992 assert(ClassDecl->needsImplicitMoveConstructor());
15993
15994 DeclaringSpecialMember DSM(*this, ClassDecl,
15995 CXXSpecialMemberKind::MoveConstructor);
15996 if (DSM.isAlreadyBeingDeclared())
15997 return nullptr;
15998
15999 QualType ClassType = Context.getTagType(Keyword: ElaboratedTypeKeyword::None,
16000 /*Qualifier=*/std::nullopt, TD: ClassDecl,
16001 /*OwnsTag=*/false);
16002
16003 QualType ArgType = ClassType;
16004 LangAS AS = getDefaultCXXMethodAddrSpace();
16005 if (AS != LangAS::Default)
16006 ArgType = Context.getAddrSpaceQualType(T: ClassType, AddressSpace: AS);
16007 ArgType = Context.getRValueReferenceType(T: ArgType);
16008
16009 bool Constexpr = defaultedSpecialMemberIsConstexpr(
16010 S&: *this, ClassDecl, CSM: CXXSpecialMemberKind::MoveConstructor, ConstArg: false);
16011
16012 DeclarationName Name
16013 = Context.DeclarationNames.getCXXConstructorName(
16014 Ty: Context.getCanonicalType(T: ClassType));
16015 SourceLocation ClassLoc = ClassDecl->getLocation();
16016 DeclarationNameInfo NameInfo(Name, ClassLoc);
16017
16018 // C++11 [class.copy]p11:
16019 // An implicitly-declared copy/move constructor is an inline public
16020 // member of its class.
16021 CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
16022 C&: Context, RD: ClassDecl, StartLoc: ClassLoc, NameInfo, T: QualType(), /*TInfo=*/nullptr,
16023 ES: ExplicitSpecifier(), UsesFPIntrin: getCurFPFeatures().isFPConstrained(),
16024 /*isInline=*/true,
16025 /*isImplicitlyDeclared=*/true,
16026 ConstexprKind: Constexpr ? ConstexprSpecKind::Constexpr
16027 : ConstexprSpecKind::Unspecified);
16028 MoveConstructor->setAccess(AS_public);
16029 MoveConstructor->setDefaulted();
16030
16031 setupImplicitSpecialMemberType(SpecialMem: MoveConstructor, ResultTy: Context.VoidTy, Args: ArgType);
16032
16033 if (getLangOpts().CUDA)
16034 CUDA().inferTargetForImplicitSpecialMember(
16035 ClassDecl, CSM: CXXSpecialMemberKind::MoveConstructor, MemberDecl: MoveConstructor,
16036 /* ConstRHS */ false,
16037 /* Diagnose */ false);
16038
16039 // Add the parameter to the constructor.
16040 ParmVarDecl *FromParam = ParmVarDecl::Create(C&: Context, DC: MoveConstructor,
16041 StartLoc: ClassLoc, IdLoc: ClassLoc,
16042 /*IdentifierInfo=*/Id: nullptr,
16043 T: ArgType, /*TInfo=*/nullptr,
16044 S: SC_None, DefArg: nullptr);
16045 MoveConstructor->setParams(FromParam);
16046
16047 MoveConstructor->setTrivial(
16048 ClassDecl->needsOverloadResolutionForMoveConstructor()
16049 ? SpecialMemberIsTrivial(MD: MoveConstructor,
16050 CSM: CXXSpecialMemberKind::MoveConstructor)
16051 : ClassDecl->hasTrivialMoveConstructor());
16052
16053 MoveConstructor->setTrivialForCall(
16054 ClassDecl->hasAttr<TrivialABIAttr>() ||
16055 (ClassDecl->needsOverloadResolutionForMoveConstructor()
16056 ? SpecialMemberIsTrivial(MD: MoveConstructor,
16057 CSM: CXXSpecialMemberKind::MoveConstructor,
16058 TAH: TrivialABIHandling::ConsiderTrivialABI)
16059 : ClassDecl->hasTrivialMoveConstructorForCall()));
16060
16061 // Note that we have declared this constructor.
16062 ++getASTContext().NumImplicitMoveConstructorsDeclared;
16063
16064 Scope *S = getScopeForContext(Ctx: ClassDecl);
16065 CheckImplicitSpecialMemberDeclaration(S, FD: MoveConstructor);
16066
16067 if (ShouldDeleteSpecialMember(MD: MoveConstructor,
16068 CSM: CXXSpecialMemberKind::MoveConstructor)) {
16069 ClassDecl->setImplicitMoveConstructorIsDeleted();
16070 SetDeclDeleted(dcl: MoveConstructor, DelLoc: ClassLoc);
16071 }
16072
16073 if (S)
16074 PushOnScopeChains(D: MoveConstructor, S, AddToContext: false);
16075 ClassDecl->addDecl(D: MoveConstructor);
16076
16077 return MoveConstructor;
16078}
16079
16080void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
16081 CXXConstructorDecl *MoveConstructor) {
16082 assert((MoveConstructor->isDefaulted() &&
16083 MoveConstructor->isMoveConstructor() &&
16084 !MoveConstructor->doesThisDeclarationHaveABody() &&
16085 !MoveConstructor->isDeleted()) &&
16086 "DefineImplicitMoveConstructor - call it for implicit move ctor");
16087 if (MoveConstructor->willHaveBody() || MoveConstructor->isInvalidDecl())
16088 return;
16089
16090 CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
16091 assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
16092
16093 SynthesizedFunctionScope Scope(*this, MoveConstructor);
16094
16095 // The exception specification is needed because we are defining the
16096 // function.
16097 ResolveExceptionSpec(Loc: CurrentLocation,
16098 FPT: MoveConstructor->getType()->castAs<FunctionProtoType>());
16099 MarkVTableUsed(Loc: CurrentLocation, Class: ClassDecl);
16100
16101 // Add a context note for diagnostics produced after this point.
16102 Scope.addContextNote(UseLoc: CurrentLocation);
16103
16104 if (SetCtorInitializers(Constructor: MoveConstructor, /*AnyErrors=*/false)) {
16105 MoveConstructor->setInvalidDecl();
16106 } else {
16107 SourceLocation Loc = MoveConstructor->getEndLoc().isValid()
16108 ? MoveConstructor->getEndLoc()
16109 : MoveConstructor->getLocation();
16110 Sema::CompoundScopeRAII CompoundScope(*this);
16111 MoveConstructor->setBody(
16112 ActOnCompoundStmt(L: Loc, R: Loc, Elts: {}, /*isStmtExpr=*/false).getAs<Stmt>());
16113 MoveConstructor->markUsed(C&: Context);
16114 }
16115
16116 if (ASTMutationListener *L = getASTMutationListener()) {
16117 L->CompletedImplicitDefinition(D: MoveConstructor);
16118 }
16119}
16120
16121bool Sema::isImplicitlyDeleted(FunctionDecl *FD) {
16122 return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(Val: FD);
16123}
16124
16125void Sema::DefineImplicitLambdaToFunctionPointerConversion(
16126 SourceLocation CurrentLocation,
16127 CXXConversionDecl *Conv) {
16128 SynthesizedFunctionScope Scope(*this, Conv);
16129 assert(!Conv->getReturnType()->isUndeducedType());
16130
16131 QualType ConvRT = Conv->getType()->castAs<FunctionType>()->getReturnType();
16132 CallingConv CC =
16133 ConvRT->getPointeeType()->castAs<FunctionType>()->getCallConv();
16134
16135 CXXRecordDecl *Lambda = Conv->getParent();
16136 FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
16137 FunctionDecl *Invoker =
16138 CallOp->hasCXXExplicitFunctionObjectParameter() || CallOp->isStatic()
16139 ? CallOp
16140 : Lambda->getLambdaStaticInvoker(CC);
16141
16142 if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
16143 CallOp = InstantiateFunctionDeclaration(
16144 FTD: CallOp->getDescribedFunctionTemplate(), Args: TemplateArgs, Loc: CurrentLocation);
16145 if (!CallOp)
16146 return;
16147
16148 if (CallOp != Invoker) {
16149 Invoker = InstantiateFunctionDeclaration(
16150 FTD: Invoker->getDescribedFunctionTemplate(), Args: TemplateArgs,
16151 Loc: CurrentLocation);
16152 if (!Invoker)
16153 return;
16154 }
16155 }
16156
16157 if (CallOp->isInvalidDecl())
16158 return;
16159
16160 // Mark the call operator referenced (and add to pending instantiations
16161 // if necessary).
16162 // For both the conversion and static-invoker template specializations
16163 // we construct their body's in this function, so no need to add them
16164 // to the PendingInstantiations.
16165 MarkFunctionReferenced(Loc: CurrentLocation, Func: CallOp);
16166
16167 if (Invoker != CallOp) {
16168 // Fill in the __invoke function with a dummy implementation. IR generation
16169 // will fill in the actual details. Update its type in case it contained
16170 // an 'auto'.
16171 Invoker->markUsed(C&: Context);
16172 Invoker->setReferenced();
16173 Invoker->setType(Conv->getReturnType()->getPointeeType());
16174 Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
16175 }
16176
16177 // Construct the body of the conversion function { return __invoke; }.
16178 Expr *FunctionRef = BuildDeclRefExpr(D: Invoker, Ty: Invoker->getType(), VK: VK_LValue,
16179 Loc: Conv->getLocation());
16180 assert(FunctionRef && "Can't refer to __invoke function?");
16181 Stmt *Return = BuildReturnStmt(ReturnLoc: Conv->getLocation(), RetValExp: FunctionRef).get();
16182 Conv->setBody(CompoundStmt::Create(C: Context, Stmts: Return, FPFeatures: FPOptionsOverride(),
16183 LB: Conv->getLocation(), RB: Conv->getLocation()));
16184 Conv->markUsed(C&: Context);
16185 Conv->setReferenced();
16186
16187 if (ASTMutationListener *L = getASTMutationListener()) {
16188 L->CompletedImplicitDefinition(D: Conv);
16189 if (Invoker != CallOp)
16190 L->CompletedImplicitDefinition(D: Invoker);
16191 }
16192}
16193
16194void Sema::DefineImplicitLambdaToBlockPointerConversion(
16195 SourceLocation CurrentLocation, CXXConversionDecl *Conv) {
16196 assert(!Conv->getParent()->isGenericLambda());
16197
16198 SynthesizedFunctionScope Scope(*this, Conv);
16199
16200 // Copy-initialize the lambda object as needed to capture it.
16201 Expr *This = ActOnCXXThis(Loc: CurrentLocation).get();
16202 Expr *DerefThis =CreateBuiltinUnaryOp(OpLoc: CurrentLocation, Opc: UO_Deref, InputExpr: This).get();
16203
16204 ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
16205 ConvLocation: Conv->getLocation(),
16206 Conv, Src: DerefThis);
16207
16208 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
16209 // behavior. Note that only the general conversion function does this
16210 // (since it's unusable otherwise); in the case where we inline the
16211 // block literal, it has block literal lifetime semantics.
16212 if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
16213 BuildBlock = ImplicitCastExpr::Create(
16214 Context, T: BuildBlock.get()->getType(), Kind: CK_CopyAndAutoreleaseBlockObject,
16215 Operand: BuildBlock.get(), BasePath: nullptr, Cat: VK_PRValue, FPO: FPOptionsOverride());
16216
16217 if (BuildBlock.isInvalid()) {
16218 Diag(Loc: CurrentLocation, DiagID: diag::note_lambda_to_block_conv);
16219 Conv->setInvalidDecl();
16220 return;
16221 }
16222
16223 // Create the return statement that returns the block from the conversion
16224 // function.
16225 StmtResult Return = BuildReturnStmt(ReturnLoc: Conv->getLocation(), RetValExp: BuildBlock.get());
16226 if (Return.isInvalid()) {
16227 Diag(Loc: CurrentLocation, DiagID: diag::note_lambda_to_block_conv);
16228 Conv->setInvalidDecl();
16229 return;
16230 }
16231
16232 // Set the body of the conversion function.
16233 Stmt *ReturnS = Return.get();
16234 Conv->setBody(CompoundStmt::Create(C: Context, Stmts: ReturnS, FPFeatures: FPOptionsOverride(),
16235 LB: Conv->getLocation(), RB: Conv->getLocation()));
16236 Conv->markUsed(C&: Context);
16237
16238 // We're done; notify the mutation listener, if any.
16239 if (ASTMutationListener *L = getASTMutationListener()) {
16240 L->CompletedImplicitDefinition(D: Conv);
16241 }
16242}
16243
16244/// Determine whether the given list arguments contains exactly one
16245/// "real" (non-default) argument.
16246static bool hasOneRealArgument(MultiExprArg Args) {
16247 switch (Args.size()) {
16248 case 0:
16249 return false;
16250
16251 default:
16252 if (!Args[1]->isDefaultArgument())
16253 return false;
16254
16255 [[fallthrough]];
16256 case 1:
16257 return !Args[0]->isDefaultArgument();
16258 }
16259
16260 return false;
16261}
16262
16263ExprResult Sema::BuildCXXConstructExpr(
16264 SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl,
16265 CXXConstructorDecl *Constructor, MultiExprArg ExprArgs,
16266 bool HadMultipleCandidates, bool IsListInitialization,
16267 bool IsStdInitListInitialization, bool RequiresZeroInit,
16268 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
16269 bool Elidable = false;
16270
16271 // C++0x [class.copy]p34:
16272 // When certain criteria are met, an implementation is allowed to
16273 // omit the copy/move construction of a class object, even if the
16274 // copy/move constructor and/or destructor for the object have
16275 // side effects. [...]
16276 // - when a temporary class object that has not been bound to a
16277 // reference (12.2) would be copied/moved to a class object
16278 // with the same cv-unqualified type, the copy/move operation
16279 // can be omitted by constructing the temporary object
16280 // directly into the target of the omitted copy/move
16281 if (ConstructKind == CXXConstructionKind::Complete && Constructor &&
16282 // FIXME: Converting constructors should also be accepted.
16283 // But to fix this, the logic that digs down into a CXXConstructExpr
16284 // to find the source object needs to handle it.
16285 // Right now it assumes the source object is passed directly as the
16286 // first argument.
16287 Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(Args: ExprArgs)) {
16288 Expr *SubExpr = ExprArgs[0];
16289 // FIXME: Per above, this is also incorrect if we want to accept
16290 // converting constructors, as isTemporaryObject will
16291 // reject temporaries with different type from the
16292 // CXXRecord itself.
16293 Elidable = SubExpr->isTemporaryObject(
16294 Ctx&: Context, TempTy: cast<CXXRecordDecl>(Val: FoundDecl->getDeclContext()));
16295 }
16296
16297 return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
16298 FoundDecl, Constructor,
16299 Elidable, Exprs: ExprArgs, HadMultipleCandidates,
16300 IsListInitialization,
16301 IsStdInitListInitialization, RequiresZeroInit,
16302 ConstructKind, ParenRange);
16303}
16304
16305ExprResult Sema::BuildCXXConstructExpr(
16306 SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl,
16307 CXXConstructorDecl *Constructor, bool Elidable, MultiExprArg ExprArgs,
16308 bool HadMultipleCandidates, bool IsListInitialization,
16309 bool IsStdInitListInitialization, bool RequiresZeroInit,
16310 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
16311 if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(Val: FoundDecl)) {
16312 Constructor = findInheritingConstructor(Loc: ConstructLoc, BaseCtor: Constructor, Shadow);
16313 // The only way to get here is if we did overload resolution to find the
16314 // shadow decl, so we don't need to worry about re-checking the trailing
16315 // requires clause.
16316 if (DiagnoseUseOfOverloadedDecl(D: Constructor, Loc: ConstructLoc))
16317 return ExprError();
16318 }
16319
16320 return BuildCXXConstructExpr(
16321 ConstructLoc, DeclInitType, Constructor, Elidable, Exprs: ExprArgs,
16322 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
16323 RequiresZeroInit, ConstructKind, ParenRange);
16324}
16325
16326/// BuildCXXConstructExpr - Creates a complete call to a constructor,
16327/// including handling of its default argument expressions.
16328ExprResult Sema::BuildCXXConstructExpr(
16329 SourceLocation ConstructLoc, QualType DeclInitType,
16330 CXXConstructorDecl *Constructor, bool Elidable, MultiExprArg ExprArgs,
16331 bool HadMultipleCandidates, bool IsListInitialization,
16332 bool IsStdInitListInitialization, bool RequiresZeroInit,
16333 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
16334 assert(declaresSameEntity(
16335 Constructor->getParent(),
16336 DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
16337 "given constructor for wrong type");
16338 MarkFunctionReferenced(Loc: ConstructLoc, Func: Constructor);
16339 if (getLangOpts().CUDA && !CUDA().CheckCall(Loc: ConstructLoc, Callee: Constructor))
16340 return ExprError();
16341
16342 return CheckForImmediateInvocation(
16343 E: CXXConstructExpr::Create(
16344 Ctx: Context, Ty: DeclInitType, Loc: ConstructLoc, Ctor: Constructor, Elidable, Args: ExprArgs,
16345 HadMultipleCandidates, ListInitialization: IsListInitialization,
16346 StdInitListInitialization: IsStdInitListInitialization, ZeroInitialization: RequiresZeroInit,
16347 ConstructKind: static_cast<CXXConstructionKind>(ConstructKind), ParenOrBraceRange: ParenRange),
16348 Decl: Constructor);
16349}
16350
16351void Sema::FinalizeVarWithDestructor(VarDecl *VD, CXXRecordDecl *ClassDecl) {
16352 if (VD->isInvalidDecl()) return;
16353 // If initializing the variable failed, don't also diagnose problems with
16354 // the destructor, they're likely related.
16355 if (VD->getInit() && VD->getInit()->containsErrors())
16356 return;
16357
16358 ClassDecl = ClassDecl->getDefinitionOrSelf();
16359 if (ClassDecl->isInvalidDecl()) return;
16360 if (ClassDecl->hasIrrelevantDestructor()) return;
16361 if (ClassDecl->isDependentContext()) return;
16362
16363 if (VD->isNoDestroy(getASTContext()))
16364 return;
16365
16366 CXXDestructorDecl *Destructor = LookupDestructor(Class: ClassDecl);
16367 // The result of `LookupDestructor` might be nullptr if the destructor is
16368 // invalid, in which case it is marked as `IneligibleOrNotSelected` and
16369 // will not be selected by `CXXRecordDecl::getDestructor()`.
16370 if (!Destructor)
16371 return;
16372 // If this is an array, we'll require the destructor during initialization, so
16373 // we can skip over this. We still want to emit exit-time destructor warnings
16374 // though.
16375 if (!VD->getType()->isArrayType()) {
16376 MarkFunctionReferenced(Loc: VD->getLocation(), Func: Destructor);
16377 CheckDestructorAccess(Loc: VD->getLocation(), Dtor: Destructor,
16378 PDiag: PDiag(DiagID: diag::err_access_dtor_var)
16379 << VD->getDeclName() << VD->getType());
16380 DiagnoseUseOfDecl(D: Destructor, Locs: VD->getLocation());
16381 }
16382
16383 if (Destructor->isTrivial()) return;
16384
16385 // If the destructor is constexpr, check whether the variable has constant
16386 // destruction now.
16387 if (Destructor->isConstexpr()) {
16388 bool HasConstantInit = false;
16389 if (VD->getInit() && !VD->getInit()->isValueDependent())
16390 HasConstantInit = VD->evaluateValue();
16391 SmallVector<PartialDiagnosticAt, 8> Notes;
16392 if (!VD->evaluateDestruction(Notes) && VD->isConstexpr() &&
16393 HasConstantInit) {
16394 Diag(Loc: VD->getLocation(),
16395 DiagID: diag::err_constexpr_var_requires_const_destruction) << VD;
16396 for (const PartialDiagnosticAt &Note : Notes)
16397 Diag(Loc: Note.first, PD: Note.second);
16398 }
16399 }
16400
16401 if (!VD->hasGlobalStorage() || !VD->needsDestruction(Ctx: Context))
16402 return;
16403
16404 // Emit warning for non-trivial dtor in global scope (a real global,
16405 // class-static, function-static).
16406 if (!VD->hasAttr<AlwaysDestroyAttr>())
16407 Diag(Loc: VD->getLocation(), DiagID: diag::warn_exit_time_destructor);
16408
16409 // TODO: this should be re-enabled for static locals by !CXAAtExit
16410 if (!VD->isStaticLocal())
16411 Diag(Loc: VD->getLocation(), DiagID: diag::warn_global_destructor);
16412}
16413
16414bool Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
16415 QualType DeclInitType, MultiExprArg ArgsPtr,
16416 SourceLocation Loc,
16417 SmallVectorImpl<Expr *> &ConvertedArgs,
16418 bool AllowExplicit,
16419 bool IsListInitialization) {
16420 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
16421 unsigned NumArgs = ArgsPtr.size();
16422 Expr **Args = ArgsPtr.data();
16423
16424 const auto *Proto = Constructor->getType()->castAs<FunctionProtoType>();
16425 unsigned NumParams = Proto->getNumParams();
16426
16427 // If too few arguments are available, we'll fill in the rest with defaults.
16428 if (NumArgs < NumParams)
16429 ConvertedArgs.reserve(N: NumParams);
16430 else
16431 ConvertedArgs.reserve(N: NumArgs);
16432
16433 VariadicCallType CallType = Proto->isVariadic()
16434 ? VariadicCallType::Constructor
16435 : VariadicCallType::DoesNotApply;
16436 SmallVector<Expr *, 8> AllArgs;
16437 bool Invalid = GatherArgumentsForCall(
16438 CallLoc: Loc, FDecl: Constructor, Proto, FirstParam: 0, Args: llvm::ArrayRef(Args, NumArgs), AllArgs,
16439 CallType, AllowExplicit, IsListInitialization);
16440 ConvertedArgs.append(in_start: AllArgs.begin(), in_end: AllArgs.end());
16441
16442 DiagnoseSentinelCalls(D: Constructor, Loc, Args: AllArgs);
16443
16444 CheckConstructorCall(FDecl: Constructor, ThisType: DeclInitType, Args: llvm::ArrayRef(AllArgs),
16445 Proto, Loc);
16446
16447 return Invalid;
16448}
16449
16450TypeAwareAllocationMode Sema::ShouldUseTypeAwareOperatorNewOrDelete() const {
16451 bool SeenTypedOperators = Context.hasSeenTypeAwareOperatorNewOrDelete();
16452 return typeAwareAllocationModeFromBool(IsTypeAwareAllocation: SeenTypedOperators);
16453}
16454
16455FunctionDecl *
16456Sema::BuildTypeAwareUsualDelete(FunctionTemplateDecl *FnTemplateDecl,
16457 QualType DeallocType, SourceLocation Loc) {
16458 if (DeallocType.isNull())
16459 return nullptr;
16460
16461 FunctionDecl *FnDecl = FnTemplateDecl->getTemplatedDecl();
16462 if (!FnDecl->isTypeAwareOperatorNewOrDelete())
16463 return nullptr;
16464
16465 if (FnDecl->isVariadic())
16466 return nullptr;
16467
16468 unsigned NumParams = FnDecl->getNumParams();
16469 constexpr unsigned RequiredParameterCount =
16470 FunctionDecl::RequiredTypeAwareDeleteParameterCount;
16471 // A usual deallocation function has no placement parameters
16472 if (NumParams != RequiredParameterCount)
16473 return nullptr;
16474
16475 // A type aware allocation is only usual if the only dependent parameter is
16476 // the first parameter.
16477 if (llvm::any_of(Range: FnDecl->parameters().drop_front(),
16478 P: [](const ParmVarDecl *ParamDecl) {
16479 return ParamDecl->getType()->isDependentType();
16480 }))
16481 return nullptr;
16482
16483 QualType SpecializedTypeIdentity = tryBuildStdTypeIdentity(Type: DeallocType, Loc);
16484 if (SpecializedTypeIdentity.isNull())
16485 return nullptr;
16486
16487 SmallVector<QualType, RequiredParameterCount> ArgTypes;
16488 ArgTypes.reserve(N: NumParams);
16489
16490 // The first parameter to a type aware operator delete is by definition the
16491 // type-identity argument, so we explicitly set this to the target
16492 // type-identity type, the remaining usual parameters should then simply match
16493 // the type declared in the function template.
16494 ArgTypes.push_back(Elt: SpecializedTypeIdentity);
16495 for (unsigned ParamIdx = 1; ParamIdx < RequiredParameterCount; ++ParamIdx)
16496 ArgTypes.push_back(Elt: FnDecl->getParamDecl(i: ParamIdx)->getType());
16497
16498 FunctionProtoType::ExtProtoInfo EPI;
16499 QualType ExpectedFunctionType =
16500 Context.getFunctionType(ResultTy: Context.VoidTy, Args: ArgTypes, EPI);
16501 sema::TemplateDeductionInfo Info(Loc);
16502 FunctionDecl *Result;
16503 if (DeduceTemplateArguments(FunctionTemplate: FnTemplateDecl, ExplicitTemplateArgs: nullptr, ArgFunctionType: ExpectedFunctionType,
16504 Specialization&: Result, Info) != TemplateDeductionResult::Success)
16505 return nullptr;
16506 return Result;
16507}
16508
16509static inline bool
16510CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
16511 const FunctionDecl *FnDecl) {
16512 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
16513 if (isa<NamespaceDecl>(Val: DC)) {
16514 return SemaRef.Diag(Loc: FnDecl->getLocation(),
16515 DiagID: diag::err_operator_new_delete_declared_in_namespace)
16516 << FnDecl->getDeclName();
16517 }
16518
16519 if (isa<TranslationUnitDecl>(Val: DC) &&
16520 FnDecl->getStorageClass() == SC_Static) {
16521 return SemaRef.Diag(Loc: FnDecl->getLocation(),
16522 DiagID: diag::err_operator_new_delete_declared_static)
16523 << FnDecl->getDeclName();
16524 }
16525
16526 return false;
16527}
16528
16529static CanQualType RemoveAddressSpaceFromPtr(Sema &SemaRef,
16530 const PointerType *PtrTy) {
16531 auto &Ctx = SemaRef.Context;
16532 Qualifiers PtrQuals = PtrTy->getPointeeType().getQualifiers();
16533 PtrQuals.removeAddressSpace();
16534 return Ctx.getPointerType(T: Ctx.getCanonicalType(T: Ctx.getQualifiedType(
16535 T: PtrTy->getPointeeType().getUnqualifiedType(), Qs: PtrQuals)));
16536}
16537
16538enum class AllocationOperatorKind { New, Delete };
16539
16540static bool IsPotentiallyTypeAwareOperatorNewOrDelete(Sema &SemaRef,
16541 const FunctionDecl *FD,
16542 bool *WasMalformed) {
16543 const Decl *MalformedDecl = nullptr;
16544 if (FD->getNumParams() > 0 &&
16545 SemaRef.isStdTypeIdentity(Ty: FD->getParamDecl(i: 0)->getType(),
16546 /*TypeArgument=*/Element: nullptr, MalformedDecl: &MalformedDecl))
16547 return true;
16548
16549 if (!MalformedDecl)
16550 return false;
16551
16552 if (WasMalformed)
16553 *WasMalformed = true;
16554
16555 return true;
16556}
16557
16558static bool isDestroyingDeleteT(QualType Type) {
16559 auto *RD = Type->getAsCXXRecordDecl();
16560 return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
16561 RD->getIdentifier()->isStr(Str: "destroying_delete_t");
16562}
16563
16564static bool IsPotentiallyDestroyingOperatorDelete(Sema &SemaRef,
16565 const FunctionDecl *FD) {
16566 // C++ P0722:
16567 // Within a class C, a single object deallocation function with signature
16568 // (T, std::destroying_delete_t, <more params>)
16569 // is a destroying operator delete.
16570 bool IsPotentiallyTypeAware = IsPotentiallyTypeAwareOperatorNewOrDelete(
16571 SemaRef, FD, /*WasMalformed=*/nullptr);
16572 unsigned DestroyingDeleteIdx = IsPotentiallyTypeAware + /* address */ 1;
16573 return isa<CXXMethodDecl>(Val: FD) && FD->getOverloadedOperator() == OO_Delete &&
16574 FD->getNumParams() > DestroyingDeleteIdx &&
16575 isDestroyingDeleteT(Type: FD->getParamDecl(i: DestroyingDeleteIdx)->getType());
16576}
16577
16578static inline bool CheckOperatorNewDeleteTypes(
16579 Sema &SemaRef, FunctionDecl *FnDecl, AllocationOperatorKind OperatorKind,
16580 CanQualType ExpectedResultType, CanQualType ExpectedSizeOrAddressParamType,
16581 unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag) {
16582 auto NormalizeType = [&SemaRef](QualType T) {
16583 if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
16584 // The operator is valid on any address space for OpenCL.
16585 // Drop address space from actual and expected result types.
16586 if (const auto PtrTy = T->template getAs<PointerType>())
16587 T = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
16588 }
16589 return SemaRef.Context.getCanonicalType(T);
16590 };
16591
16592 const unsigned NumParams = FnDecl->getNumParams();
16593 unsigned FirstNonTypeParam = 0;
16594 bool MalformedTypeIdentity = false;
16595 bool IsPotentiallyTypeAware = IsPotentiallyTypeAwareOperatorNewOrDelete(
16596 SemaRef, FD: FnDecl, WasMalformed: &MalformedTypeIdentity);
16597 unsigned MinimumMandatoryArgumentCount = 1;
16598 unsigned SizeParameterIndex = 0;
16599 if (IsPotentiallyTypeAware) {
16600 // We don't emit this diagnosis for template instantiations as we will
16601 // have already emitted it for the original template declaration.
16602 if (!FnDecl->isTemplateInstantiation())
16603 SemaRef.Diag(Loc: FnDecl->getLocation(), DiagID: diag::warn_ext_type_aware_allocators);
16604
16605 if (OperatorKind == AllocationOperatorKind::New) {
16606 SizeParameterIndex = 1;
16607 MinimumMandatoryArgumentCount =
16608 FunctionDecl::RequiredTypeAwareNewParameterCount;
16609 } else {
16610 SizeParameterIndex = 2;
16611 MinimumMandatoryArgumentCount =
16612 FunctionDecl::RequiredTypeAwareDeleteParameterCount;
16613 }
16614 FirstNonTypeParam = 1;
16615 }
16616
16617 bool IsPotentiallyDestroyingDelete =
16618 IsPotentiallyDestroyingOperatorDelete(SemaRef, FD: FnDecl);
16619
16620 if (IsPotentiallyDestroyingDelete) {
16621 ++MinimumMandatoryArgumentCount;
16622 ++SizeParameterIndex;
16623 }
16624
16625 if (NumParams < MinimumMandatoryArgumentCount)
16626 return SemaRef.Diag(Loc: FnDecl->getLocation(),
16627 DiagID: diag::err_operator_new_delete_too_few_parameters)
16628 << IsPotentiallyTypeAware << IsPotentiallyDestroyingDelete
16629 << FnDecl->getDeclName() << MinimumMandatoryArgumentCount;
16630
16631 for (unsigned Idx = 0; Idx < MinimumMandatoryArgumentCount; ++Idx) {
16632 const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(i: Idx);
16633 if (ParamDecl->hasDefaultArg())
16634 return SemaRef.Diag(Loc: FnDecl->getLocation(),
16635 DiagID: diag::err_operator_new_default_arg)
16636 << FnDecl->getDeclName() << Idx << ParamDecl->getDefaultArgRange();
16637 }
16638
16639 auto *FnType = FnDecl->getType()->castAs<FunctionType>();
16640 QualType CanResultType = NormalizeType(FnType->getReturnType());
16641 QualType CanExpectedResultType = NormalizeType(ExpectedResultType);
16642 QualType CanExpectedSizeOrAddressParamType =
16643 NormalizeType(ExpectedSizeOrAddressParamType);
16644
16645 // Check that the result type is what we expect.
16646 if (CanResultType != CanExpectedResultType) {
16647 // Reject even if the type is dependent; an operator delete function is
16648 // required to have a non-dependent result type.
16649 return SemaRef.Diag(
16650 Loc: FnDecl->getLocation(),
16651 DiagID: CanResultType->isDependentType()
16652 ? diag::err_operator_new_delete_dependent_result_type
16653 : diag::err_operator_new_delete_invalid_result_type)
16654 << FnDecl->getDeclName() << ExpectedResultType;
16655 }
16656
16657 // A function template must have at least 2 parameters.
16658 if (FnDecl->getDescribedFunctionTemplate() && NumParams < 2)
16659 return SemaRef.Diag(Loc: FnDecl->getLocation(),
16660 DiagID: diag::err_operator_new_delete_template_too_few_parameters)
16661 << FnDecl->getDeclName();
16662
16663 auto CheckType = [&](unsigned ParamIdx, QualType ExpectedType,
16664 auto FallbackType) -> bool {
16665 const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(i: ParamIdx);
16666 if (ExpectedType.isNull()) {
16667 return SemaRef.Diag(Loc: FnDecl->getLocation(), DiagID: InvalidParamTypeDiag)
16668 << IsPotentiallyTypeAware << IsPotentiallyDestroyingDelete
16669 << FnDecl->getDeclName() << (1 + ParamIdx) << FallbackType
16670 << ParamDecl->getSourceRange();
16671 }
16672 CanQualType CanExpectedTy =
16673 NormalizeType(SemaRef.Context.getCanonicalType(T: ExpectedType));
16674 auto ActualParamType =
16675 NormalizeType(ParamDecl->getType().getUnqualifiedType());
16676 if (ActualParamType == CanExpectedTy)
16677 return false;
16678 unsigned Diagnostic = ActualParamType->isDependentType()
16679 ? DependentParamTypeDiag
16680 : InvalidParamTypeDiag;
16681 return SemaRef.Diag(Loc: FnDecl->getLocation(), DiagID: Diagnostic)
16682 << IsPotentiallyTypeAware << IsPotentiallyDestroyingDelete
16683 << FnDecl->getDeclName() << (1 + ParamIdx) << ExpectedType
16684 << FallbackType << ParamDecl->getSourceRange();
16685 };
16686
16687 // Check that the first parameter type is what we expect.
16688 if (CheckType(FirstNonTypeParam, CanExpectedSizeOrAddressParamType, "size_t"))
16689 return true;
16690
16691 FnDecl->setIsDestroyingOperatorDelete(IsPotentiallyDestroyingDelete);
16692
16693 // If the first parameter type is not a type-identity we're done, otherwise
16694 // we need to ensure the size and alignment parameters have the correct type
16695 if (!IsPotentiallyTypeAware)
16696 return false;
16697
16698 if (CheckType(SizeParameterIndex, SemaRef.Context.getSizeType(), "size_t"))
16699 return true;
16700 TagDecl *StdAlignValTDecl = SemaRef.getStdAlignValT();
16701 CanQualType StdAlignValT =
16702 StdAlignValTDecl ? SemaRef.Context.getCanonicalTagType(TD: StdAlignValTDecl)
16703 : CanQualType();
16704 if (CheckType(SizeParameterIndex + 1, StdAlignValT, "std::align_val_t"))
16705 return true;
16706
16707 FnDecl->setIsTypeAwareOperatorNewOrDelete();
16708 return MalformedTypeIdentity;
16709}
16710
16711static bool CheckOperatorNewDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
16712 // C++ [basic.stc.dynamic.allocation]p1:
16713 // A program is ill-formed if an allocation function is declared in a
16714 // namespace scope other than global scope or declared static in global
16715 // scope.
16716 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
16717 return true;
16718
16719 CanQualType SizeTy =
16720 SemaRef.Context.getCanonicalType(T: SemaRef.Context.getSizeType());
16721
16722 // C++ [basic.stc.dynamic.allocation]p1:
16723 // The return type shall be void*. The first parameter shall have type
16724 // std::size_t.
16725 return CheckOperatorNewDeleteTypes(
16726 SemaRef, FnDecl, OperatorKind: AllocationOperatorKind::New, ExpectedResultType: SemaRef.Context.VoidPtrTy,
16727 ExpectedSizeOrAddressParamType: SizeTy, DependentParamTypeDiag: diag::err_operator_new_dependent_param_type,
16728 InvalidParamTypeDiag: diag::err_operator_new_param_type);
16729}
16730
16731static bool
16732CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
16733 // C++ [basic.stc.dynamic.deallocation]p1:
16734 // A program is ill-formed if deallocation functions are declared in a
16735 // namespace scope other than global scope or declared static in global
16736 // scope.
16737 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
16738 return true;
16739
16740 auto *MD = dyn_cast<CXXMethodDecl>(Val: FnDecl);
16741 auto ConstructDestroyingDeleteAddressType = [&]() {
16742 assert(MD);
16743 return SemaRef.Context.getPointerType(
16744 T: SemaRef.Context.getCanonicalTagType(TD: MD->getParent()));
16745 };
16746
16747 // C++ P2719: A destroying operator delete cannot be type aware
16748 // so for QoL we actually check for this explicitly by considering
16749 // an destroying-delete appropriate address type and the presence of
16750 // any parameter of type destroying_delete_t as an erroneous attempt
16751 // to declare a type aware destroying delete, rather than emitting a
16752 // pile of incorrect parameter type errors.
16753 if (MD && IsPotentiallyTypeAwareOperatorNewOrDelete(
16754 SemaRef, FD: MD, /*WasMalformed=*/nullptr)) {
16755 QualType AddressParamType =
16756 SemaRef.Context.getCanonicalType(T: MD->getParamDecl(i: 1)->getType());
16757 if (AddressParamType != SemaRef.Context.VoidPtrTy &&
16758 AddressParamType == ConstructDestroyingDeleteAddressType()) {
16759 // The address parameter type implies an author trying to construct a
16760 // type aware destroying delete, so we'll see if we can find a parameter
16761 // of type `std::destroying_delete_t`, and if we find it we'll report
16762 // this as being an attempt at a type aware destroying delete just stop
16763 // here. If we don't do this, the resulting incorrect parameter ordering
16764 // results in a pile mismatched argument type errors that don't explain
16765 // the core problem.
16766 for (auto Param : MD->parameters()) {
16767 if (isDestroyingDeleteT(Type: Param->getType())) {
16768 SemaRef.Diag(Loc: MD->getLocation(),
16769 DiagID: diag::err_type_aware_destroying_operator_delete)
16770 << Param->getSourceRange();
16771 return true;
16772 }
16773 }
16774 }
16775 }
16776
16777 // C++ P0722:
16778 // Within a class C, the first parameter of a destroying operator delete
16779 // shall be of type C *. The first parameter of any other deallocation
16780 // function shall be of type void *.
16781 CanQualType ExpectedAddressParamType =
16782 MD && IsPotentiallyDestroyingOperatorDelete(SemaRef, FD: MD)
16783 ? SemaRef.Context.getPointerType(
16784 T: SemaRef.Context.getCanonicalTagType(TD: MD->getParent()))
16785 : SemaRef.Context.VoidPtrTy;
16786
16787 // C++ [basic.stc.dynamic.deallocation]p2:
16788 // Each deallocation function shall return void
16789 if (CheckOperatorNewDeleteTypes(
16790 SemaRef, FnDecl, OperatorKind: AllocationOperatorKind::Delete,
16791 ExpectedResultType: SemaRef.Context.VoidTy, ExpectedSizeOrAddressParamType: ExpectedAddressParamType,
16792 DependentParamTypeDiag: diag::err_operator_delete_dependent_param_type,
16793 InvalidParamTypeDiag: diag::err_operator_delete_param_type))
16794 return true;
16795
16796 // C++ P0722:
16797 // A destroying operator delete shall be a usual deallocation function.
16798 if (MD && !MD->getParent()->isDependentContext() &&
16799 MD->isDestroyingOperatorDelete()) {
16800 if (!SemaRef.isUsualDeallocationFunction(FD: MD)) {
16801 SemaRef.Diag(Loc: MD->getLocation(),
16802 DiagID: diag::err_destroying_operator_delete_not_usual);
16803 return true;
16804 }
16805 }
16806
16807 return false;
16808}
16809
16810bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
16811 assert(FnDecl && FnDecl->isOverloadedOperator() &&
16812 "Expected an overloaded operator declaration");
16813
16814 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
16815
16816 // C++ [over.oper]p5:
16817 // The allocation and deallocation functions, operator new,
16818 // operator new[], operator delete and operator delete[], are
16819 // described completely in 3.7.3. The attributes and restrictions
16820 // found in the rest of this subclause do not apply to them unless
16821 // explicitly stated in 3.7.3.
16822 if (Op == OO_Delete || Op == OO_Array_Delete)
16823 return CheckOperatorDeleteDeclaration(SemaRef&: *this, FnDecl);
16824
16825 if (Op == OO_New || Op == OO_Array_New)
16826 return CheckOperatorNewDeclaration(SemaRef&: *this, FnDecl);
16827
16828 // C++ [over.oper]p7:
16829 // An operator function shall either be a member function or
16830 // be a non-member function and have at least one parameter
16831 // whose type is a class, a reference to a class, an enumeration,
16832 // or a reference to an enumeration.
16833 // Note: Before C++23, a member function could not be static. The only member
16834 // function allowed to be static is the call operator function.
16835 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(Val: FnDecl)) {
16836 if (MethodDecl->isStatic()) {
16837 if (Op == OO_Call || Op == OO_Subscript)
16838 Diag(Loc: FnDecl->getLocation(),
16839 DiagID: (LangOpts.CPlusPlus23
16840 ? diag::warn_cxx20_compat_operator_overload_static
16841 : diag::ext_operator_overload_static))
16842 << FnDecl;
16843 else
16844 return Diag(Loc: FnDecl->getLocation(), DiagID: diag::err_operator_overload_static)
16845 << FnDecl;
16846 }
16847 } else {
16848 bool ClassOrEnumParam = false;
16849 for (auto *Param : FnDecl->parameters()) {
16850 QualType ParamType = Param->getType().getNonReferenceType();
16851 if (ParamType->isDependentType() || ParamType->isRecordType() ||
16852 ParamType->isEnumeralType()) {
16853 ClassOrEnumParam = true;
16854 break;
16855 }
16856 }
16857
16858 if (!ClassOrEnumParam)
16859 return Diag(Loc: FnDecl->getLocation(),
16860 DiagID: diag::err_operator_overload_needs_class_or_enum)
16861 << FnDecl->getDeclName();
16862 }
16863
16864 // C++ [over.oper]p8:
16865 // An operator function cannot have default arguments (8.3.6),
16866 // except where explicitly stated below.
16867 //
16868 // Only the function-call operator (C++ [over.call]p1) and the subscript
16869 // operator (CWG2507) allow default arguments.
16870 if (Op != OO_Call) {
16871 ParmVarDecl *FirstDefaultedParam = nullptr;
16872 for (auto *Param : FnDecl->parameters()) {
16873 if (Param->hasDefaultArg()) {
16874 FirstDefaultedParam = Param;
16875 break;
16876 }
16877 }
16878 if (FirstDefaultedParam) {
16879 if (Op == OO_Subscript) {
16880 Diag(Loc: FnDecl->getLocation(), DiagID: LangOpts.CPlusPlus23
16881 ? diag::ext_subscript_overload
16882 : diag::error_subscript_overload)
16883 << FnDecl->getDeclName() << 1
16884 << FirstDefaultedParam->getDefaultArgRange();
16885 } else {
16886 return Diag(Loc: FirstDefaultedParam->getLocation(),
16887 DiagID: diag::err_operator_overload_default_arg)
16888 << FnDecl->getDeclName()
16889 << FirstDefaultedParam->getDefaultArgRange();
16890 }
16891 }
16892 }
16893
16894 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
16895 { false, false, false }
16896#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
16897 , { Unary, Binary, MemberOnly }
16898#include "clang/Basic/OperatorKinds.def"
16899 };
16900
16901 bool CanBeUnaryOperator = OperatorUses[Op][0];
16902 bool CanBeBinaryOperator = OperatorUses[Op][1];
16903 bool MustBeMemberOperator = OperatorUses[Op][2];
16904
16905 // C++ [over.oper]p8:
16906 // [...] Operator functions cannot have more or fewer parameters
16907 // than the number required for the corresponding operator, as
16908 // described in the rest of this subclause.
16909 unsigned NumParams = FnDecl->getNumParams() +
16910 (isa<CXXMethodDecl>(Val: FnDecl) &&
16911 !FnDecl->hasCXXExplicitFunctionObjectParameter()
16912 ? 1
16913 : 0);
16914 if (Op != OO_Call && Op != OO_Subscript &&
16915 ((NumParams == 1 && !CanBeUnaryOperator) ||
16916 (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) ||
16917 (NumParams > 2))) {
16918 // We have the wrong number of parameters.
16919 unsigned ErrorKind;
16920 if (CanBeUnaryOperator && CanBeBinaryOperator) {
16921 ErrorKind = 2; // 2 -> unary or binary.
16922 } else if (CanBeUnaryOperator) {
16923 ErrorKind = 0; // 0 -> unary
16924 } else {
16925 assert(CanBeBinaryOperator &&
16926 "All non-call overloaded operators are unary or binary!");
16927 ErrorKind = 1; // 1 -> binary
16928 }
16929 return Diag(Loc: FnDecl->getLocation(), DiagID: diag::err_operator_overload_must_be)
16930 << FnDecl->getDeclName() << NumParams << ErrorKind;
16931 }
16932
16933 if (Op == OO_Subscript && NumParams != 2) {
16934 Diag(Loc: FnDecl->getLocation(), DiagID: LangOpts.CPlusPlus23
16935 ? diag::ext_subscript_overload
16936 : diag::error_subscript_overload)
16937 << FnDecl->getDeclName() << (NumParams == 1 ? 0 : 2);
16938 }
16939
16940 // Overloaded operators other than operator() and operator[] cannot be
16941 // variadic.
16942 if (Op != OO_Call &&
16943 FnDecl->getType()->castAs<FunctionProtoType>()->isVariadic()) {
16944 return Diag(Loc: FnDecl->getLocation(), DiagID: diag::err_operator_overload_variadic)
16945 << FnDecl->getDeclName();
16946 }
16947
16948 // Some operators must be member functions.
16949 if (MustBeMemberOperator && !isa<CXXMethodDecl>(Val: FnDecl)) {
16950 return Diag(Loc: FnDecl->getLocation(),
16951 DiagID: diag::err_operator_overload_must_be_member)
16952 << FnDecl->getDeclName();
16953 }
16954
16955 // C++ [over.inc]p1:
16956 // The user-defined function called operator++ implements the
16957 // prefix and postfix ++ operator. If this function is a member
16958 // function with no parameters, or a non-member function with one
16959 // parameter of class or enumeration type, it defines the prefix
16960 // increment operator ++ for objects of that type. If the function
16961 // is a member function with one parameter (which shall be of type
16962 // int) or a non-member function with two parameters (the second
16963 // of which shall be of type int), it defines the postfix
16964 // increment operator ++ for objects of that type.
16965 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
16966 ParmVarDecl *LastParam = FnDecl->getParamDecl(i: FnDecl->getNumParams() - 1);
16967 QualType ParamType = LastParam->getType();
16968
16969 if (!ParamType->isSpecificBuiltinType(K: BuiltinType::Int) &&
16970 !ParamType->isDependentType())
16971 return Diag(Loc: LastParam->getLocation(),
16972 DiagID: diag::err_operator_overload_post_incdec_must_be_int)
16973 << LastParam->getType() << (Op == OO_MinusMinus);
16974 }
16975
16976 return false;
16977}
16978
16979static bool
16980checkLiteralOperatorTemplateParameterList(Sema &SemaRef,
16981 FunctionTemplateDecl *TpDecl) {
16982 TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();
16983
16984 // Must have one or two template parameters.
16985 if (TemplateParams->size() == 1) {
16986 NonTypeTemplateParmDecl *PmDecl =
16987 dyn_cast<NonTypeTemplateParmDecl>(Val: TemplateParams->getParam(Idx: 0));
16988
16989 // The template parameter must be a char parameter pack.
16990 if (PmDecl && PmDecl->isTemplateParameterPack() &&
16991 SemaRef.Context.hasSameType(T1: PmDecl->getType(), T2: SemaRef.Context.CharTy))
16992 return false;
16993
16994 // C++20 [over.literal]p5:
16995 // A string literal operator template is a literal operator template
16996 // whose template-parameter-list comprises a single non-type
16997 // template-parameter of class type.
16998 //
16999 // As a DR resolution, we also allow placeholders for deduced class
17000 // template specializations.
17001 if (SemaRef.getLangOpts().CPlusPlus20 && PmDecl &&
17002 !PmDecl->isTemplateParameterPack() &&
17003 (PmDecl->getType()->isRecordType() ||
17004 PmDecl->getType()->getAs<DeducedTemplateSpecializationType>()))
17005 return false;
17006 } else if (TemplateParams->size() == 2) {
17007 TemplateTypeParmDecl *PmType =
17008 dyn_cast<TemplateTypeParmDecl>(Val: TemplateParams->getParam(Idx: 0));
17009 NonTypeTemplateParmDecl *PmArgs =
17010 dyn_cast<NonTypeTemplateParmDecl>(Val: TemplateParams->getParam(Idx: 1));
17011
17012 // The second template parameter must be a parameter pack with the
17013 // first template parameter as its type.
17014 if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
17015 PmArgs->isTemplateParameterPack()) {
17016 if (const auto *TArgs =
17017 PmArgs->getType()->getAsCanonical<TemplateTypeParmType>();
17018 TArgs && TArgs->getDepth() == PmType->getDepth() &&
17019 TArgs->getIndex() == PmType->getIndex()) {
17020 if (!SemaRef.inTemplateInstantiation())
17021 SemaRef.Diag(Loc: TpDecl->getLocation(),
17022 DiagID: diag::ext_string_literal_operator_template);
17023 return false;
17024 }
17025 }
17026 }
17027
17028 SemaRef.Diag(Loc: TpDecl->getTemplateParameters()->getSourceRange().getBegin(),
17029 DiagID: diag::err_literal_operator_template)
17030 << TpDecl->getTemplateParameters()->getSourceRange();
17031 return true;
17032}
17033
17034bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
17035 if (isa<CXXMethodDecl>(Val: FnDecl)) {
17036 Diag(Loc: FnDecl->getLocation(), DiagID: diag::err_literal_operator_outside_namespace)
17037 << FnDecl->getDeclName();
17038 return true;
17039 }
17040
17041 if (FnDecl->isExternC()) {
17042 Diag(Loc: FnDecl->getLocation(), DiagID: diag::err_literal_operator_extern_c);
17043 if (const LinkageSpecDecl *LSD =
17044 FnDecl->getDeclContext()->getExternCContext())
17045 Diag(Loc: LSD->getExternLoc(), DiagID: diag::note_extern_c_begins_here);
17046 return true;
17047 }
17048
17049 // This might be the definition of a literal operator template.
17050 FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate();
17051
17052 // This might be a specialization of a literal operator template.
17053 if (!TpDecl)
17054 TpDecl = FnDecl->getPrimaryTemplate();
17055
17056 // template <char...> type operator "" name() and
17057 // template <class T, T...> type operator "" name() are the only valid
17058 // template signatures, and the only valid signatures with no parameters.
17059 //
17060 // C++20 also allows template <SomeClass T> type operator "" name().
17061 if (TpDecl) {
17062 if (FnDecl->param_size() != 0) {
17063 Diag(Loc: FnDecl->getLocation(),
17064 DiagID: diag::err_literal_operator_template_with_params);
17065 return true;
17066 }
17067
17068 if (checkLiteralOperatorTemplateParameterList(SemaRef&: *this, TpDecl))
17069 return true;
17070
17071 } else if (FnDecl->param_size() == 1) {
17072 const ParmVarDecl *Param = FnDecl->getParamDecl(i: 0);
17073
17074 QualType ParamType = Param->getType().getUnqualifiedType();
17075
17076 // Only unsigned long long int, long double, any character type, and const
17077 // char * are allowed as the only parameters.
17078 if (ParamType->isSpecificBuiltinType(K: BuiltinType::ULongLong) ||
17079 ParamType->isSpecificBuiltinType(K: BuiltinType::LongDouble) ||
17080 Context.hasSameType(T1: ParamType, T2: Context.CharTy) ||
17081 Context.hasSameType(T1: ParamType, T2: Context.WideCharTy) ||
17082 Context.hasSameType(T1: ParamType, T2: Context.Char8Ty) ||
17083 Context.hasSameType(T1: ParamType, T2: Context.Char16Ty) ||
17084 Context.hasSameType(T1: ParamType, T2: Context.Char32Ty)) {
17085 } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
17086 QualType InnerType = Ptr->getPointeeType();
17087
17088 // Pointer parameter must be a const char *.
17089 if (!(Context.hasSameType(T1: InnerType.getUnqualifiedType(),
17090 T2: Context.CharTy) &&
17091 InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
17092 Diag(Loc: Param->getSourceRange().getBegin(),
17093 DiagID: diag::err_literal_operator_param)
17094 << ParamType << "'const char *'" << Param->getSourceRange();
17095 return true;
17096 }
17097
17098 } else if (ParamType->isRealFloatingType()) {
17099 Diag(Loc: Param->getSourceRange().getBegin(), DiagID: diag::err_literal_operator_param)
17100 << ParamType << Context.LongDoubleTy << Param->getSourceRange();
17101 return true;
17102
17103 } else if (ParamType->isIntegerType()) {
17104 Diag(Loc: Param->getSourceRange().getBegin(), DiagID: diag::err_literal_operator_param)
17105 << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
17106 return true;
17107
17108 } else {
17109 Diag(Loc: Param->getSourceRange().getBegin(),
17110 DiagID: diag::err_literal_operator_invalid_param)
17111 << ParamType << Param->getSourceRange();
17112 return true;
17113 }
17114
17115 } else if (FnDecl->param_size() == 2) {
17116 FunctionDecl::param_iterator Param = FnDecl->param_begin();
17117
17118 // First, verify that the first parameter is correct.
17119
17120 QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
17121
17122 // Two parameter function must have a pointer to const as a
17123 // first parameter; let's strip those qualifiers.
17124 const PointerType *PT = FirstParamType->getAs<PointerType>();
17125
17126 if (!PT) {
17127 Diag(Loc: (*Param)->getSourceRange().getBegin(),
17128 DiagID: diag::err_literal_operator_param)
17129 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
17130 return true;
17131 }
17132
17133 QualType PointeeType = PT->getPointeeType();
17134 // First parameter must be const
17135 if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
17136 Diag(Loc: (*Param)->getSourceRange().getBegin(),
17137 DiagID: diag::err_literal_operator_param)
17138 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
17139 return true;
17140 }
17141
17142 QualType InnerType = PointeeType.getUnqualifiedType();
17143 // Only const char *, const wchar_t*, const char8_t*, const char16_t*, and
17144 // const char32_t* are allowed as the first parameter to a two-parameter
17145 // function
17146 if (!(Context.hasSameType(T1: InnerType, T2: Context.CharTy) ||
17147 Context.hasSameType(T1: InnerType, T2: Context.WideCharTy) ||
17148 Context.hasSameType(T1: InnerType, T2: Context.Char8Ty) ||
17149 Context.hasSameType(T1: InnerType, T2: Context.Char16Ty) ||
17150 Context.hasSameType(T1: InnerType, T2: Context.Char32Ty))) {
17151 Diag(Loc: (*Param)->getSourceRange().getBegin(),
17152 DiagID: diag::err_literal_operator_param)
17153 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
17154 return true;
17155 }
17156
17157 // Move on to the second and final parameter.
17158 ++Param;
17159
17160 // The second parameter must be a std::size_t.
17161 QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
17162 if (!Context.hasSameType(T1: SecondParamType, T2: Context.getSizeType())) {
17163 Diag(Loc: (*Param)->getSourceRange().getBegin(),
17164 DiagID: diag::err_literal_operator_param)
17165 << SecondParamType << Context.getSizeType()
17166 << (*Param)->getSourceRange();
17167 return true;
17168 }
17169 } else {
17170 Diag(Loc: FnDecl->getLocation(), DiagID: diag::err_literal_operator_bad_param_count);
17171 return true;
17172 }
17173
17174 // Parameters are good.
17175
17176 // A parameter-declaration-clause containing a default argument is not
17177 // equivalent to any of the permitted forms.
17178 for (auto *Param : FnDecl->parameters()) {
17179 if (Param->hasDefaultArg()) {
17180 Diag(Loc: Param->getDefaultArgRange().getBegin(),
17181 DiagID: diag::err_literal_operator_default_argument)
17182 << Param->getDefaultArgRange();
17183 break;
17184 }
17185 }
17186
17187 const IdentifierInfo *II = FnDecl->getDeclName().getCXXLiteralIdentifier();
17188 ReservedLiteralSuffixIdStatus Status = II->isReservedLiteralSuffixId();
17189 if (Status != ReservedLiteralSuffixIdStatus::NotReserved &&
17190 !getSourceManager().isInSystemHeader(Loc: FnDecl->getLocation())) {
17191 // C++23 [usrlit.suffix]p1:
17192 // Literal suffix identifiers that do not start with an underscore are
17193 // reserved for future standardization. Literal suffix identifiers that
17194 // contain a double underscore __ are reserved for use by C++
17195 // implementations.
17196 Diag(Loc: FnDecl->getLocation(), DiagID: diag::warn_user_literal_reserved)
17197 << static_cast<int>(Status)
17198 << StringLiteralParser::isValidUDSuffix(LangOpts: getLangOpts(), Suffix: II->getName());
17199 }
17200
17201 return false;
17202}
17203
17204Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
17205 Expr *LangStr,
17206 SourceLocation LBraceLoc) {
17207 StringLiteral *Lit = cast<StringLiteral>(Val: LangStr);
17208 assert(Lit->isUnevaluated() && "Unexpected string literal kind");
17209
17210 StringRef Lang = Lit->getString();
17211 LinkageSpecLanguageIDs Language;
17212 if (Lang == "C")
17213 Language = LinkageSpecLanguageIDs::C;
17214 else if (Lang == "C++")
17215 Language = LinkageSpecLanguageIDs::CXX;
17216 else {
17217 Diag(Loc: LangStr->getExprLoc(), DiagID: diag::err_language_linkage_spec_unknown)
17218 << LangStr->getSourceRange();
17219 return nullptr;
17220 }
17221
17222 // FIXME: Add all the various semantics of linkage specifications
17223
17224 LinkageSpecDecl *D = LinkageSpecDecl::Create(C&: Context, DC: CurContext, ExternLoc,
17225 LangLoc: LangStr->getExprLoc(), Lang: Language,
17226 HasBraces: LBraceLoc.isValid());
17227
17228 /// C++ [module.unit]p7.2.3
17229 /// - Otherwise, if the declaration
17230 /// - ...
17231 /// - ...
17232 /// - appears within a linkage-specification,
17233 /// it is attached to the global module.
17234 ///
17235 /// If the declaration is already in global module fragment, we don't
17236 /// need to attach it again.
17237 if (getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
17238 Module *GlobalModule = PushImplicitGlobalModuleFragment(BeginLoc: ExternLoc);
17239 D->setLocalOwningModule(GlobalModule);
17240 }
17241
17242 CurContext->addDecl(D);
17243 PushDeclContext(S, DC: D);
17244 return D;
17245}
17246
17247Decl *Sema::ActOnFinishLinkageSpecification(Scope *S,
17248 Decl *LinkageSpec,
17249 SourceLocation RBraceLoc) {
17250 if (RBraceLoc.isValid()) {
17251 LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(Val: LinkageSpec);
17252 LSDecl->setRBraceLoc(RBraceLoc);
17253 }
17254
17255 // If the current module doesn't has Parent, it implies that the
17256 // LinkageSpec isn't in the module created by itself. So we don't
17257 // need to pop it.
17258 if (getLangOpts().CPlusPlusModules && getCurrentModule() &&
17259 getCurrentModule()->isImplicitGlobalModule() &&
17260 getCurrentModule()->Parent)
17261 PopImplicitGlobalModuleFragment();
17262
17263 PopDeclContext();
17264 return LinkageSpec;
17265}
17266
17267Decl *Sema::ActOnEmptyDeclaration(Scope *S,
17268 const ParsedAttributesView &AttrList,
17269 SourceLocation SemiLoc) {
17270 Decl *ED = EmptyDecl::Create(C&: Context, DC: CurContext, L: SemiLoc);
17271 // Attribute declarations appertain to empty declaration so we handle
17272 // them here.
17273 ProcessDeclAttributeList(S, D: ED, AttrList);
17274
17275 CurContext->addDecl(D: ED);
17276 return ED;
17277}
17278
17279VarDecl *Sema::BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,
17280 SourceLocation StartLoc,
17281 SourceLocation Loc,
17282 const IdentifierInfo *Name) {
17283 bool Invalid = false;
17284 QualType ExDeclType = TInfo->getType();
17285
17286 // Arrays and functions decay.
17287 if (ExDeclType->isArrayType())
17288 ExDeclType = Context.getArrayDecayedType(T: ExDeclType);
17289 else if (ExDeclType->isFunctionType())
17290 ExDeclType = Context.getPointerType(T: ExDeclType);
17291
17292 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
17293 // The exception-declaration shall not denote a pointer or reference to an
17294 // incomplete type, other than [cv] void*.
17295 // N2844 forbids rvalue references.
17296 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
17297 Diag(Loc, DiagID: diag::err_catch_rvalue_ref);
17298 Invalid = true;
17299 }
17300
17301 if (ExDeclType->isVariablyModifiedType()) {
17302 Diag(Loc, DiagID: diag::err_catch_variably_modified) << ExDeclType;
17303 Invalid = true;
17304 }
17305
17306 QualType BaseType = ExDeclType;
17307 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
17308 unsigned DK = diag::err_catch_incomplete;
17309 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
17310 BaseType = Ptr->getPointeeType();
17311 Mode = 1;
17312 DK = diag::err_catch_incomplete_ptr;
17313 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
17314 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
17315 BaseType = Ref->getPointeeType();
17316 Mode = 2;
17317 DK = diag::err_catch_incomplete_ref;
17318 }
17319 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
17320 !BaseType->isDependentType() && RequireCompleteType(Loc, T: BaseType, DiagID: DK))
17321 Invalid = true;
17322
17323 if (!Invalid && BaseType.isWebAssemblyReferenceType()) {
17324 Diag(Loc, DiagID: diag::err_wasm_reftype_tc) << 1;
17325 Invalid = true;
17326 }
17327
17328 if (!Invalid && Mode != 1 && BaseType->isSizelessType()) {
17329 Diag(Loc, DiagID: diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
17330 Invalid = true;
17331 }
17332
17333 if (!Invalid && !ExDeclType->isDependentType() &&
17334 RequireNonAbstractType(Loc, T: ExDeclType,
17335 DiagID: diag::err_abstract_type_in_decl,
17336 Args: AbstractVariableType))
17337 Invalid = true;
17338
17339 // Only the non-fragile NeXT runtime currently supports C++ catches
17340 // of ObjC types, and no runtime supports catching ObjC types by value.
17341 if (!Invalid && getLangOpts().ObjC) {
17342 QualType T = ExDeclType;
17343 if (const ReferenceType *RT = T->getAs<ReferenceType>())
17344 T = RT->getPointeeType();
17345
17346 if (T->isObjCObjectType()) {
17347 Diag(Loc, DiagID: diag::err_objc_object_catch);
17348 Invalid = true;
17349 } else if (T->isObjCObjectPointerType()) {
17350 // FIXME: should this be a test for macosx-fragile specifically?
17351 if (getLangOpts().ObjCRuntime.isFragile())
17352 Diag(Loc, DiagID: diag::warn_objc_pointer_cxx_catch_fragile);
17353 }
17354 }
17355
17356 VarDecl *ExDecl = VarDecl::Create(C&: Context, DC: CurContext, StartLoc, IdLoc: Loc, Id: Name,
17357 T: ExDeclType, TInfo, S: SC_None);
17358 ExDecl->setExceptionVariable(true);
17359
17360 // In ARC, infer 'retaining' for variables of retainable type.
17361 if (getLangOpts().ObjCAutoRefCount && ObjC().inferObjCARCLifetime(decl: ExDecl))
17362 Invalid = true;
17363
17364 if (!Invalid && !ExDeclType->isDependentType()) {
17365 if (auto *ClassDecl = ExDeclType->getAsCXXRecordDecl()) {
17366 // Insulate this from anything else we might currently be parsing.
17367 EnterExpressionEvaluationContext scope(
17368 *this, ExpressionEvaluationContext::PotentiallyEvaluated);
17369
17370 // C++ [except.handle]p16:
17371 // The object declared in an exception-declaration or, if the
17372 // exception-declaration does not specify a name, a temporary (12.2) is
17373 // copy-initialized (8.5) from the exception object. [...]
17374 // The object is destroyed when the handler exits, after the destruction
17375 // of any automatic objects initialized within the handler.
17376 //
17377 // We just pretend to initialize the object with itself, then make sure
17378 // it can be destroyed later.
17379 QualType initType = Context.getExceptionObjectType(T: ExDeclType);
17380
17381 InitializedEntity entity =
17382 InitializedEntity::InitializeVariable(Var: ExDecl);
17383 InitializationKind initKind =
17384 InitializationKind::CreateCopy(InitLoc: Loc, EqualLoc: SourceLocation());
17385
17386 Expr *opaqueValue =
17387 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
17388 InitializationSequence sequence(*this, entity, initKind, opaqueValue);
17389 ExprResult result = sequence.Perform(S&: *this, Entity: entity, Kind: initKind, Args: opaqueValue);
17390 if (result.isInvalid())
17391 Invalid = true;
17392 else {
17393 // If the constructor used was non-trivial, set this as the
17394 // "initializer".
17395 CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
17396 if (!construct->getConstructor()->isTrivial()) {
17397 Expr *init = MaybeCreateExprWithCleanups(SubExpr: construct);
17398 ExDecl->setInit(init);
17399 }
17400
17401 // And make sure it's destructable.
17402 FinalizeVarWithDestructor(VD: ExDecl, ClassDecl);
17403 }
17404 }
17405 }
17406
17407 if (Invalid)
17408 ExDecl->setInvalidDecl();
17409
17410 return ExDecl;
17411}
17412
17413Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
17414 TypeSourceInfo *TInfo = GetTypeForDeclarator(D);
17415 bool Invalid = D.isInvalidType();
17416
17417 // Check for unexpanded parameter packs.
17418 if (DiagnoseUnexpandedParameterPack(Loc: D.getIdentifierLoc(), T: TInfo,
17419 UPPC: UPPC_ExceptionType)) {
17420 TInfo = Context.getTrivialTypeSourceInfo(T: Context.IntTy,
17421 Loc: D.getIdentifierLoc());
17422 Invalid = true;
17423 }
17424
17425 const IdentifierInfo *II = D.getIdentifier();
17426 if (NamedDecl *PrevDecl =
17427 LookupSingleName(S, Name: II, Loc: D.getIdentifierLoc(), NameKind: LookupOrdinaryName,
17428 Redecl: RedeclarationKind::ForVisibleRedeclaration)) {
17429 // The scope should be freshly made just for us. There is just no way
17430 // it contains any previous declaration, except for function parameters in
17431 // a function-try-block's catch statement.
17432 assert(!S->isDeclScope(PrevDecl));
17433 if (isDeclInScope(D: PrevDecl, Ctx: CurContext, S)) {
17434 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_redefinition)
17435 << D.getIdentifier();
17436 Diag(Loc: PrevDecl->getLocation(), DiagID: diag::note_previous_definition);
17437 Invalid = true;
17438 } else if (PrevDecl->isTemplateParameter())
17439 // Maybe we will complain about the shadowed template parameter.
17440 DiagnoseTemplateParameterShadow(Loc: D.getIdentifierLoc(), PrevDecl);
17441 }
17442
17443 if (D.getCXXScopeSpec().isSet() && !Invalid) {
17444 Diag(Loc: D.getIdentifierLoc(), DiagID: diag::err_qualified_catch_declarator)
17445 << D.getCXXScopeSpec().getRange();
17446 Invalid = true;
17447 }
17448
17449 VarDecl *ExDecl = BuildExceptionDeclaration(
17450 S, TInfo, StartLoc: D.getBeginLoc(), Loc: D.getIdentifierLoc(), Name: D.getIdentifier());
17451 if (Invalid)
17452 ExDecl->setInvalidDecl();
17453
17454 // Add the exception declaration into this scope.
17455 if (II)
17456 PushOnScopeChains(D: ExDecl, S);
17457 else
17458 CurContext->addDecl(D: ExDecl);
17459
17460 ProcessDeclAttributes(S, D: ExDecl, PD: D);
17461 return ExDecl;
17462}
17463
17464Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
17465 Expr *AssertExpr,
17466 Expr *AssertMessageExpr,
17467 SourceLocation RParenLoc) {
17468 if (DiagnoseUnexpandedParameterPack(E: AssertExpr, UPPC: UPPC_StaticAssertExpression))
17469 return nullptr;
17470
17471 return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
17472 AssertMessageExpr, RParenLoc, Failed: false);
17473}
17474
17475static void WriteCharTypePrefix(BuiltinType::Kind BTK, llvm::raw_ostream &OS) {
17476 switch (BTK) {
17477 case BuiltinType::Char_S:
17478 case BuiltinType::Char_U:
17479 break;
17480 case BuiltinType::Char8:
17481 OS << "u8";
17482 break;
17483 case BuiltinType::Char16:
17484 OS << 'u';
17485 break;
17486 case BuiltinType::Char32:
17487 OS << 'U';
17488 break;
17489 case BuiltinType::WChar_S:
17490 case BuiltinType::WChar_U:
17491 OS << 'L';
17492 break;
17493 default:
17494 llvm_unreachable("Non-character type");
17495 }
17496}
17497
17498/// Convert character's value, interpreted as a code unit, to a string.
17499/// The value needs to be zero-extended to 32-bits.
17500/// FIXME: This assumes Unicode literal encodings
17501static void WriteCharValueForDiagnostic(uint32_t Value, const BuiltinType *BTy,
17502 unsigned TyWidth,
17503 SmallVectorImpl<char> &Str) {
17504 char Arr[UNI_MAX_UTF8_BYTES_PER_CODE_POINT];
17505 char *Ptr = Arr;
17506 BuiltinType::Kind K = BTy->getKind();
17507 llvm::raw_svector_ostream OS(Str);
17508
17509 // This should catch Char_S, Char_U, Char8, and use of escaped characters in
17510 // other types.
17511 if (K == BuiltinType::Char_S || K == BuiltinType::Char_U ||
17512 K == BuiltinType::Char8 || Value <= 0x7F) {
17513 StringRef Escaped = escapeCStyle<EscapeChar::Single>(Ch: Value);
17514 if (!Escaped.empty())
17515 EscapeStringForDiagnostic(Str: Escaped, OutStr&: Str);
17516 else
17517 OS << static_cast<char>(Value);
17518 return;
17519 }
17520
17521 switch (K) {
17522 case BuiltinType::Char16:
17523 case BuiltinType::Char32:
17524 case BuiltinType::WChar_S:
17525 case BuiltinType::WChar_U: {
17526 if (llvm::ConvertCodePointToUTF8(Source: Value, ResultPtr&: Ptr))
17527 EscapeStringForDiagnostic(Str: StringRef(Arr, Ptr - Arr), OutStr&: Str);
17528 else
17529 OS << "\\x"
17530 << llvm::format_hex_no_prefix(N: Value, Width: TyWidth / 4, /*Upper=*/true);
17531 break;
17532 }
17533 default:
17534 llvm_unreachable("Non-character type is passed");
17535 }
17536}
17537
17538/// Convert \V to a string we can present to the user in a diagnostic
17539/// \T is the type of the expression that has been evaluated into \V
17540static bool ConvertAPValueToString(const APValue &V, QualType T,
17541 SmallVectorImpl<char> &Str,
17542 ASTContext &Context) {
17543 if (!V.hasValue())
17544 return false;
17545
17546 switch (V.getKind()) {
17547 case APValue::ValueKind::Int:
17548 if (T->isBooleanType()) {
17549 // Bools are reduced to ints during evaluation, but for
17550 // diagnostic purposes we want to print them as
17551 // true or false.
17552 int64_t BoolValue = V.getInt().getExtValue();
17553 assert((BoolValue == 0 || BoolValue == 1) &&
17554 "Bool type, but value is not 0 or 1");
17555 llvm::raw_svector_ostream OS(Str);
17556 OS << (BoolValue ? "true" : "false");
17557 } else {
17558 llvm::raw_svector_ostream OS(Str);
17559 // Same is true for chars.
17560 // We want to print the character representation for textual types
17561 const auto *BTy = T->getAs<BuiltinType>();
17562 if (BTy) {
17563 switch (BTy->getKind()) {
17564 case BuiltinType::Char_S:
17565 case BuiltinType::Char_U:
17566 case BuiltinType::Char8:
17567 case BuiltinType::Char16:
17568 case BuiltinType::Char32:
17569 case BuiltinType::WChar_S:
17570 case BuiltinType::WChar_U: {
17571 unsigned TyWidth = Context.getIntWidth(T);
17572 assert(8 <= TyWidth && TyWidth <= 32 && "Unexpected integer width");
17573 uint32_t CodeUnit = static_cast<uint32_t>(V.getInt().getZExtValue());
17574 WriteCharTypePrefix(BTK: BTy->getKind(), OS);
17575 OS << '\'';
17576 WriteCharValueForDiagnostic(Value: CodeUnit, BTy, TyWidth, Str);
17577 OS << "' (0x"
17578 << llvm::format_hex_no_prefix(N: CodeUnit, /*Width=*/2,
17579 /*Upper=*/true)
17580 << ", " << V.getInt() << ')';
17581 return true;
17582 }
17583 default:
17584 break;
17585 }
17586 }
17587 V.getInt().toString(Str);
17588 }
17589
17590 break;
17591
17592 case APValue::ValueKind::Float:
17593 V.getFloat().toString(Str);
17594 break;
17595
17596 case APValue::ValueKind::LValue:
17597 if (V.isNullPointer()) {
17598 llvm::raw_svector_ostream OS(Str);
17599 OS << "nullptr";
17600 } else
17601 return false;
17602 break;
17603
17604 case APValue::ValueKind::ComplexFloat: {
17605 llvm::raw_svector_ostream OS(Str);
17606 OS << '(';
17607 V.getComplexFloatReal().toString(Str);
17608 OS << " + ";
17609 V.getComplexFloatImag().toString(Str);
17610 OS << "i)";
17611 } break;
17612
17613 case APValue::ValueKind::ComplexInt: {
17614 llvm::raw_svector_ostream OS(Str);
17615 OS << '(';
17616 V.getComplexIntReal().toString(Str);
17617 OS << " + ";
17618 V.getComplexIntImag().toString(Str);
17619 OS << "i)";
17620 } break;
17621
17622 default:
17623 return false;
17624 }
17625
17626 return true;
17627}
17628
17629/// Some Expression types are not useful to print notes about,
17630/// e.g. literals and values that have already been expanded
17631/// before such as int-valued template parameters.
17632static bool UsefulToPrintExpr(const Expr *E) {
17633 E = E->IgnoreParenImpCasts();
17634 // Literals are pretty easy for humans to understand.
17635 if (isa<IntegerLiteral, FloatingLiteral, CharacterLiteral, CXXBoolLiteralExpr,
17636 CXXNullPtrLiteralExpr, FixedPointLiteral, ImaginaryLiteral>(Val: E))
17637 return false;
17638
17639 // These have been substituted from template parameters
17640 // and appear as literals in the static assert error.
17641 if (isa<SubstNonTypeTemplateParmExpr>(Val: E))
17642 return false;
17643
17644 // -5 is also simple to understand.
17645 if (const auto *UnaryOp = dyn_cast<UnaryOperator>(Val: E))
17646 return UsefulToPrintExpr(E: UnaryOp->getSubExpr());
17647
17648 // Only print nested arithmetic operators.
17649 if (const auto *BO = dyn_cast<BinaryOperator>(Val: E))
17650 return (BO->isShiftOp() || BO->isAdditiveOp() || BO->isMultiplicativeOp() ||
17651 BO->isBitwiseOp());
17652
17653 return true;
17654}
17655
17656void Sema::DiagnoseStaticAssertDetails(const Expr *E) {
17657 if (const auto *Op = dyn_cast<BinaryOperator>(Val: E);
17658 Op && Op->getOpcode() != BO_LOr) {
17659 const Expr *LHS = Op->getLHS()->IgnoreParenImpCasts();
17660 const Expr *RHS = Op->getRHS()->IgnoreParenImpCasts();
17661
17662 // Ignore comparisons of boolean expressions with a boolean literal.
17663 if ((isa<CXXBoolLiteralExpr>(Val: LHS) && RHS->getType()->isBooleanType()) ||
17664 (isa<CXXBoolLiteralExpr>(Val: RHS) && LHS->getType()->isBooleanType()))
17665 return;
17666
17667 // Don't print obvious expressions.
17668 if (!UsefulToPrintExpr(E: LHS) && !UsefulToPrintExpr(E: RHS))
17669 return;
17670
17671 struct {
17672 const clang::Expr *Cond;
17673 Expr::EvalResult Result;
17674 SmallString<12> ValueString;
17675 bool Print;
17676 } DiagSides[2] = {{.Cond: LHS, .Result: Expr::EvalResult(), .ValueString: {}, .Print: false},
17677 {.Cond: RHS, .Result: Expr::EvalResult(), .ValueString: {}, .Print: false}};
17678 for (auto &DiagSide : DiagSides) {
17679 const Expr *Side = DiagSide.Cond;
17680
17681 Side->EvaluateAsRValue(Result&: DiagSide.Result, Ctx: Context, InConstantContext: true);
17682
17683 DiagSide.Print = ConvertAPValueToString(
17684 V: DiagSide.Result.Val, T: Side->getType(), Str&: DiagSide.ValueString, Context);
17685 }
17686 if (DiagSides[0].Print && DiagSides[1].Print) {
17687 Diag(Loc: Op->getExprLoc(), DiagID: diag::note_expr_evaluates_to)
17688 << DiagSides[0].ValueString << Op->getOpcodeStr()
17689 << DiagSides[1].ValueString << Op->getSourceRange();
17690 }
17691 } else {
17692 DiagnoseTypeTraitDetails(E);
17693 }
17694}
17695
17696template <typename ResultType>
17697static bool EvaluateAsStringImpl(Sema &SemaRef, Expr *Message,
17698 ResultType &Result, ASTContext &Ctx,
17699 Sema::StringEvaluationContext EvalContext,
17700 bool ErrorOnInvalidMessage) {
17701
17702 assert(Message);
17703 assert(!Message->isTypeDependent() && !Message->isValueDependent() &&
17704 "can't evaluate a dependant static assert message");
17705
17706 if (const auto *SL = dyn_cast<StringLiteral>(Val: Message)) {
17707 assert(SL->isUnevaluated() && "expected an unevaluated string");
17708 if constexpr (std::is_same_v<APValue, ResultType>) {
17709 Result =
17710 APValue(APValue::UninitArray{}, SL->getLength(), SL->getLength());
17711 const ConstantArrayType *CAT =
17712 SemaRef.getASTContext().getAsConstantArrayType(T: SL->getType());
17713 assert(CAT && "string literal isn't an array");
17714 QualType CharType = CAT->getElementType();
17715 llvm::APSInt Value(SemaRef.getASTContext().getTypeSize(T: CharType),
17716 CharType->isUnsignedIntegerType());
17717 for (unsigned I = 0; I < SL->getLength(); I++) {
17718 Value = SL->getCodeUnit(i: I);
17719 Result.getArrayInitializedElt(I) = APValue(Value);
17720 }
17721 } else {
17722 Result.assign(SL->getString().begin(), SL->getString().end());
17723 }
17724 return true;
17725 }
17726
17727 SourceLocation Loc = Message->getBeginLoc();
17728 QualType T = Message->getType().getNonReferenceType();
17729 auto *RD = T->getAsCXXRecordDecl();
17730 if (!RD) {
17731 SemaRef.Diag(Loc, DiagID: diag::err_user_defined_msg_invalid) << EvalContext;
17732 return false;
17733 }
17734
17735 auto FindMember = [&](StringRef Member) -> std::optional<LookupResult> {
17736 DeclarationName DN = SemaRef.PP.getIdentifierInfo(Name: Member);
17737 LookupResult MemberLookup(SemaRef, DN, Loc, Sema::LookupMemberName);
17738 SemaRef.LookupQualifiedName(R&: MemberLookup, LookupCtx: RD);
17739 OverloadCandidateSet Candidates(MemberLookup.getNameLoc(),
17740 OverloadCandidateSet::CSK_Normal);
17741 if (MemberLookup.empty())
17742 return std::nullopt;
17743 return std::move(MemberLookup);
17744 };
17745
17746 std::optional<LookupResult> SizeMember = FindMember("size");
17747 std::optional<LookupResult> DataMember = FindMember("data");
17748 if (!SizeMember || !DataMember) {
17749 SemaRef.Diag(Loc, DiagID: diag::err_user_defined_msg_missing_member_function)
17750 << EvalContext
17751 << ((!SizeMember && !DataMember) ? 2
17752 : !SizeMember ? 0
17753 : 1);
17754 return false;
17755 }
17756
17757 auto BuildExpr = [&](LookupResult &LR) {
17758 ExprResult Res = SemaRef.BuildMemberReferenceExpr(
17759 Base: Message, BaseType: Message->getType(), OpLoc: Message->getBeginLoc(), IsArrow: false,
17760 SS: CXXScopeSpec(), TemplateKWLoc: SourceLocation(), FirstQualifierInScope: nullptr, R&: LR, TemplateArgs: nullptr, S: nullptr);
17761 if (Res.isInvalid())
17762 return ExprError();
17763 Res = SemaRef.BuildCallExpr(S: nullptr, Fn: Res.get(), LParenLoc: Loc, ArgExprs: {}, RParenLoc: Loc, ExecConfig: nullptr,
17764 IsExecConfig: false, AllowRecovery: true);
17765 if (Res.isInvalid())
17766 return ExprError();
17767 if (Res.get()->isTypeDependent() || Res.get()->isValueDependent())
17768 return ExprError();
17769 return SemaRef.TemporaryMaterializationConversion(E: Res.get());
17770 };
17771
17772 ExprResult SizeE = BuildExpr(*SizeMember);
17773 ExprResult DataE = BuildExpr(*DataMember);
17774
17775 QualType SizeT = SemaRef.Context.getSizeType();
17776 QualType ConstCharPtr = SemaRef.Context.getPointerType(
17777 T: SemaRef.Context.getConstType(T: SemaRef.Context.CharTy));
17778
17779 ExprResult EvaluatedSize =
17780 SizeE.isInvalid()
17781 ? ExprError()
17782 : SemaRef.BuildConvertedConstantExpression(
17783 From: SizeE.get(), T: SizeT, CCE: CCEKind::StaticAssertMessageSize);
17784 if (EvaluatedSize.isInvalid()) {
17785 SemaRef.Diag(Loc, DiagID: diag::err_user_defined_msg_invalid_mem_fn_ret_ty)
17786 << EvalContext << /*size*/ 0;
17787 return false;
17788 }
17789
17790 ExprResult EvaluatedData =
17791 DataE.isInvalid()
17792 ? ExprError()
17793 : SemaRef.BuildConvertedConstantExpression(
17794 From: DataE.get(), T: ConstCharPtr, CCE: CCEKind::StaticAssertMessageData);
17795 if (EvaluatedData.isInvalid()) {
17796 SemaRef.Diag(Loc, DiagID: diag::err_user_defined_msg_invalid_mem_fn_ret_ty)
17797 << EvalContext << /*data*/ 1;
17798 return false;
17799 }
17800
17801 if (!ErrorOnInvalidMessage &&
17802 SemaRef.Diags.isIgnored(DiagID: diag::warn_user_defined_msg_constexpr, Loc))
17803 return true;
17804
17805 Expr::EvalResult Status;
17806 SmallVector<PartialDiagnosticAt, 8> Notes;
17807 Status.Diag = &Notes;
17808 if (!Message->EvaluateCharRangeAsString(Result, EvaluatedSize.get(),
17809 EvaluatedData.get(), Ctx, Status) ||
17810 !Notes.empty()) {
17811 SemaRef.Diag(Loc: Message->getBeginLoc(),
17812 DiagID: ErrorOnInvalidMessage ? diag::err_user_defined_msg_constexpr
17813 : diag::warn_user_defined_msg_constexpr)
17814 << EvalContext;
17815 for (const auto &Note : Notes)
17816 SemaRef.Diag(Loc: Note.first, PD: Note.second);
17817 return !ErrorOnInvalidMessage;
17818 }
17819 return true;
17820}
17821
17822bool Sema::EvaluateAsString(Expr *Message, APValue &Result, ASTContext &Ctx,
17823 StringEvaluationContext EvalContext,
17824 bool ErrorOnInvalidMessage) {
17825 return EvaluateAsStringImpl(SemaRef&: *this, Message, Result, Ctx, EvalContext,
17826 ErrorOnInvalidMessage);
17827}
17828
17829bool Sema::EvaluateAsString(Expr *Message, std::string &Result, ASTContext &Ctx,
17830 StringEvaluationContext EvalContext,
17831 bool ErrorOnInvalidMessage) {
17832 return EvaluateAsStringImpl(SemaRef&: *this, Message, Result, Ctx, EvalContext,
17833 ErrorOnInvalidMessage);
17834}
17835
17836Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
17837 Expr *AssertExpr, Expr *AssertMessage,
17838 SourceLocation RParenLoc,
17839 bool Failed) {
17840 assert(AssertExpr != nullptr && "Expected non-null condition");
17841 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
17842 (!AssertMessage || (!AssertMessage->isTypeDependent() &&
17843 !AssertMessage->isValueDependent())) &&
17844 !Failed) {
17845 // In a static_assert-declaration, the constant-expression shall be a
17846 // constant expression that can be contextually converted to bool.
17847 ExprResult Converted = PerformContextuallyConvertToBool(From: AssertExpr);
17848 if (Converted.isInvalid())
17849 Failed = true;
17850
17851 ExprResult FullAssertExpr =
17852 ActOnFinishFullExpr(Expr: Converted.get(), CC: StaticAssertLoc,
17853 /*DiscardedValue*/ false,
17854 /*IsConstexpr*/ true);
17855 if (FullAssertExpr.isInvalid())
17856 Failed = true;
17857 else
17858 AssertExpr = FullAssertExpr.get();
17859
17860 llvm::APSInt Cond;
17861 Expr *BaseExpr = AssertExpr;
17862 AllowFoldKind FoldKind = AllowFoldKind::No;
17863
17864 if (!getLangOpts().CPlusPlus) {
17865 // In C mode, allow folding as an extension for better compatibility with
17866 // C++ in terms of expressions like static_assert("test") or
17867 // static_assert(nullptr).
17868 FoldKind = AllowFoldKind::Allow;
17869 }
17870
17871 if (!Failed && VerifyIntegerConstantExpression(
17872 E: BaseExpr, Result: &Cond,
17873 DiagID: diag::err_static_assert_expression_is_not_constant,
17874 CanFold: FoldKind).isInvalid())
17875 Failed = true;
17876
17877 // If the static_assert passes, only verify that
17878 // the message is grammatically valid without evaluating it.
17879 if (!Failed && AssertMessage && Cond.getBoolValue()) {
17880 std::string Str;
17881 EvaluateAsString(Message: AssertMessage, Result&: Str, Ctx&: Context,
17882 EvalContext: StringEvaluationContext::StaticAssert,
17883 /*ErrorOnInvalidMessage=*/false);
17884 }
17885
17886 // CWG2518
17887 // [dcl.pre]/p10 If [...] the expression is evaluated in the context of a
17888 // template definition, the declaration has no effect.
17889 bool InTemplateDefinition =
17890 getLangOpts().CPlusPlus && CurContext->isDependentContext();
17891
17892 if (!Failed && !Cond && !InTemplateDefinition) {
17893 SmallString<256> MsgBuffer;
17894 llvm::raw_svector_ostream Msg(MsgBuffer);
17895 bool HasMessage = AssertMessage;
17896 if (AssertMessage) {
17897 std::string Str;
17898 HasMessage = EvaluateAsString(Message: AssertMessage, Result&: Str, Ctx&: Context,
17899 EvalContext: StringEvaluationContext::StaticAssert,
17900 /*ErrorOnInvalidMessage=*/true) ||
17901 !Str.empty();
17902 Msg << Str;
17903 }
17904 Expr *InnerCond = nullptr;
17905 std::string InnerCondDescription;
17906 std::tie(args&: InnerCond, args&: InnerCondDescription) =
17907 findFailedBooleanCondition(Cond: Converted.get());
17908 if (const auto *ConceptIDExpr =
17909 dyn_cast_or_null<ConceptSpecializationExpr>(Val: InnerCond)) {
17910 const ASTConstraintSatisfaction &Satisfaction =
17911 ConceptIDExpr->getSatisfaction();
17912 if (!Satisfaction.ContainsErrors || Satisfaction.NumRecords) {
17913 Diag(Loc: AssertExpr->getBeginLoc(), DiagID: diag::err_static_assert_failed)
17914 << !HasMessage << Msg.str() << AssertExpr->getSourceRange();
17915 // Drill down into concept specialization expressions to see why they
17916 // weren't satisfied.
17917 DiagnoseUnsatisfiedConstraint(ConstraintExpr: ConceptIDExpr);
17918 }
17919 } else if (InnerCond && !isa<CXXBoolLiteralExpr>(Val: InnerCond) &&
17920 !isa<IntegerLiteral>(Val: InnerCond)) {
17921 Diag(Loc: InnerCond->getBeginLoc(),
17922 DiagID: diag::err_static_assert_requirement_failed)
17923 << InnerCondDescription << !HasMessage << Msg.str()
17924 << InnerCond->getSourceRange();
17925 DiagnoseStaticAssertDetails(E: InnerCond);
17926 } else {
17927 Diag(Loc: AssertExpr->getBeginLoc(), DiagID: diag::err_static_assert_failed)
17928 << !HasMessage << Msg.str() << AssertExpr->getSourceRange();
17929 PrintContextStack();
17930 }
17931 Failed = true;
17932 }
17933 } else {
17934 ExprResult FullAssertExpr = ActOnFinishFullExpr(Expr: AssertExpr, CC: StaticAssertLoc,
17935 /*DiscardedValue*/false,
17936 /*IsConstexpr*/true);
17937 if (FullAssertExpr.isInvalid())
17938 Failed = true;
17939 else
17940 AssertExpr = FullAssertExpr.get();
17941 }
17942
17943 Decl *Decl = StaticAssertDecl::Create(C&: Context, DC: CurContext, StaticAssertLoc,
17944 AssertExpr, Message: AssertMessage, RParenLoc,
17945 Failed);
17946
17947 CurContext->addDecl(D: Decl);
17948 return Decl;
17949}
17950
17951DeclResult Sema::ActOnTemplatedFriendTag(
17952 Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc,
17953 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
17954 SourceLocation EllipsisLoc, const ParsedAttributesView &Attr,
17955 MultiTemplateParamsArg TempParamLists) {
17956 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TypeSpec: TagSpec);
17957
17958 bool IsMemberSpecialization = false;
17959 bool Invalid = false;
17960
17961 if (TemplateParameterList *TemplateParams =
17962 MatchTemplateParametersToScopeSpecifier(
17963 DeclStartLoc: TagLoc, DeclLoc: NameLoc, SS, TemplateId: nullptr, ParamLists: TempParamLists, /*friend*/ IsFriend: true,
17964 IsMemberSpecialization, Invalid)) {
17965 if (TemplateParams->size() > 0) {
17966 // This is a declaration of a class template.
17967 if (Invalid)
17968 return true;
17969
17970 return CheckClassTemplate(S, TagSpec, TUK: TagUseKind::Friend, KWLoc: TagLoc, SS,
17971 Name, NameLoc, Attr, TemplateParams, AS: AS_public,
17972 /*ModulePrivateLoc=*/SourceLocation(),
17973 FriendLoc, NumOuterTemplateParamLists: TempParamLists.size() - 1,
17974 OuterTemplateParamLists: TempParamLists.data())
17975 .get();
17976 } else {
17977 // The "template<>" header is extraneous.
17978 Diag(Loc: TemplateParams->getTemplateLoc(), DiagID: diag::err_template_tag_noparams)
17979 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
17980 IsMemberSpecialization = true;
17981 }
17982 }
17983
17984 if (Invalid) return true;
17985
17986 bool isAllExplicitSpecializations =
17987 llvm::all_of(Range&: TempParamLists, P: [](const TemplateParameterList *List) {
17988 return List->size() == 0;
17989 });
17990
17991 // FIXME: don't ignore attributes.
17992
17993 // If it's explicit specializations all the way down, just forget
17994 // about the template header and build an appropriate non-templated
17995 // friend. TODO: for source fidelity, remember the headers.
17996 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
17997 if (isAllExplicitSpecializations) {
17998 if (SS.isEmpty()) {
17999 bool Owned = false;
18000 bool IsDependent = false;
18001 return ActOnTag(S, TagSpec, TUK: TagUseKind::Friend, KWLoc: TagLoc, SS, Name, NameLoc,
18002 Attr, AS: AS_public,
18003 /*ModulePrivateLoc=*/SourceLocation(),
18004 TemplateParameterLists: MultiTemplateParamsArg(), OwnedDecl&: Owned, IsDependent,
18005 /*ScopedEnumKWLoc=*/SourceLocation(),
18006 /*ScopedEnumUsesClassTag=*/false,
18007 /*UnderlyingType=*/TypeResult(),
18008 /*IsTypeSpecifier=*/false,
18009 /*IsTemplateParamOrArg=*/false,
18010 /*OOK=*/OffsetOfKind::Outside);
18011 }
18012
18013 TypeSourceInfo *TSI = nullptr;
18014 ElaboratedTypeKeyword Keyword
18015 = TypeWithKeyword::getKeywordForTagTypeKind(Tag: Kind);
18016 QualType T = CheckTypenameType(Keyword, KeywordLoc: TagLoc, QualifierLoc, II: *Name,
18017 IILoc: NameLoc, TSI: &TSI, /*DeducedTSTContext=*/true);
18018 if (T.isNull())
18019 return true;
18020
18021 FriendDecl *Friend =
18022 FriendDecl::Create(C&: Context, DC: CurContext, L: NameLoc, Friend_: TSI, FriendL: FriendLoc,
18023 EllipsisLoc, FriendTypeTPLists: TempParamLists);
18024 Friend->setAccess(AS_public);
18025 CurContext->addDecl(D: Friend);
18026 return Friend;
18027 }
18028
18029 assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
18030
18031 // CWG 2917: if it (= the friend-type-specifier) is a pack expansion
18032 // (13.7.4 [temp.variadic]), any packs expanded by that pack expansion
18033 // shall not have been introduced by the template-declaration.
18034 SmallVector<UnexpandedParameterPack, 1> Unexpanded;
18035 collectUnexpandedParameterPacks(NNS: QualifierLoc, Unexpanded);
18036 unsigned FriendDeclDepth = TempParamLists.front()->getDepth();
18037 for (UnexpandedParameterPack &U : Unexpanded) {
18038 if (std::optional<std::pair<unsigned, unsigned>> DI = getDepthAndIndex(UPP: U);
18039 DI && DI->first >= FriendDeclDepth) {
18040 auto *ND = dyn_cast<NamedDecl *>(Val&: U.first);
18041 if (!ND)
18042 ND = cast<const TemplateTypeParmType *>(Val&: U.first)->getDecl();
18043 Diag(Loc: U.second, DiagID: diag::friend_template_decl_malformed_pack_expansion)
18044 << ND->getDeclName() << SourceRange(SS.getBeginLoc(), EllipsisLoc);
18045 return true;
18046 }
18047 }
18048
18049 // Handle the case of a templated-scope friend class. e.g.
18050 // template <class T> class A<T>::B;
18051 // FIXME: we don't support these right now.
18052 Diag(Loc: NameLoc, DiagID: diag::warn_template_qualified_friend_unsupported)
18053 << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(Val: CurContext);
18054 ElaboratedTypeKeyword ETK = TypeWithKeyword::getKeywordForTagTypeKind(Tag: Kind);
18055 QualType T = Context.getDependentNameType(Keyword: ETK, NNS: SS.getScopeRep(), Name);
18056 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
18057 DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
18058 TL.setElaboratedKeywordLoc(TagLoc);
18059 TL.setQualifierLoc(SS.getWithLocInContext(Context));
18060 TL.setNameLoc(NameLoc);
18061
18062 FriendDecl *Friend =
18063 FriendDecl::Create(C&: Context, DC: CurContext, L: NameLoc, Friend_: TSI, FriendL: FriendLoc,
18064 EllipsisLoc, FriendTypeTPLists: TempParamLists);
18065 Friend->setAccess(AS_public);
18066 Friend->setUnsupportedFriend(true);
18067 CurContext->addDecl(D: Friend);
18068 return Friend;
18069}
18070
18071Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
18072 MultiTemplateParamsArg TempParams,
18073 SourceLocation EllipsisLoc) {
18074 SourceLocation Loc = DS.getBeginLoc();
18075 SourceLocation FriendLoc = DS.getFriendSpecLoc();
18076
18077 assert(DS.isFriendSpecified());
18078 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
18079
18080 // C++ [class.friend]p3:
18081 // A friend declaration that does not declare a function shall have one of
18082 // the following forms:
18083 // friend elaborated-type-specifier ;
18084 // friend simple-type-specifier ;
18085 // friend typename-specifier ;
18086 //
18087 // If the friend keyword isn't first, or if the declarations has any type
18088 // qualifiers, then the declaration doesn't have that form.
18089 if (getLangOpts().CPlusPlus11 && !DS.isFriendSpecifiedFirst())
18090 Diag(Loc: FriendLoc, DiagID: diag::err_friend_not_first_in_declaration);
18091 if (DS.getTypeQualifiers()) {
18092 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
18093 Diag(Loc: DS.getConstSpecLoc(), DiagID: diag::err_friend_decl_spec) << "const";
18094 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
18095 Diag(Loc: DS.getVolatileSpecLoc(), DiagID: diag::err_friend_decl_spec) << "volatile";
18096 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
18097 Diag(Loc: DS.getRestrictSpecLoc(), DiagID: diag::err_friend_decl_spec) << "restrict";
18098 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
18099 Diag(Loc: DS.getAtomicSpecLoc(), DiagID: diag::err_friend_decl_spec) << "_Atomic";
18100 if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)
18101 Diag(Loc: DS.getUnalignedSpecLoc(), DiagID: diag::err_friend_decl_spec) << "__unaligned";
18102 }
18103
18104 // Try to convert the decl specifier to a type. This works for
18105 // friend templates because ActOnTag never produces a ClassTemplateDecl
18106 // for a TagUseKind::Friend.
18107 Declarator TheDeclarator(DS, ParsedAttributesView::none(),
18108 DeclaratorContext::Member);
18109 TypeSourceInfo *TSI = GetTypeForDeclarator(D&: TheDeclarator);
18110 QualType T = TSI->getType();
18111 if (TheDeclarator.isInvalidType())
18112 return nullptr;
18113
18114 // If '...' is present, the type must contain an unexpanded parameter
18115 // pack, and vice versa.
18116 bool Invalid = false;
18117 if (EllipsisLoc.isInvalid() &&
18118 DiagnoseUnexpandedParameterPack(Loc, T: TSI, UPPC: UPPC_FriendDeclaration))
18119 return nullptr;
18120 if (EllipsisLoc.isValid() &&
18121 !TSI->getType()->containsUnexpandedParameterPack()) {
18122 Diag(Loc: EllipsisLoc, DiagID: diag::err_pack_expansion_without_parameter_packs)
18123 << TSI->getTypeLoc().getSourceRange();
18124 Invalid = true;
18125 }
18126
18127 if (!T->isElaboratedTypeSpecifier()) {
18128 if (TempParams.size()) {
18129 // C++23 [dcl.pre]p5:
18130 // In a simple-declaration, the optional init-declarator-list can be
18131 // omitted only when declaring a class or enumeration, that is, when
18132 // the decl-specifier-seq contains either a class-specifier, an
18133 // elaborated-type-specifier with a class-key, or an enum-specifier.
18134 //
18135 // The declaration of a template-declaration or explicit-specialization
18136 // is never a member-declaration, so this must be a simple-declaration
18137 // with no init-declarator-list. Therefore, this is ill-formed.
18138 Diag(Loc, DiagID: diag::err_tagless_friend_type_template) << DS.getSourceRange();
18139 return nullptr;
18140 } else if (const RecordDecl *RD = T->getAsRecordDecl()) {
18141 SmallString<16> InsertionText(" ");
18142 InsertionText += RD->getKindName();
18143
18144 Diag(Loc, DiagID: getLangOpts().CPlusPlus11
18145 ? diag::warn_cxx98_compat_unelaborated_friend_type
18146 : diag::ext_unelaborated_friend_type)
18147 << (unsigned)RD->getTagKind() << T
18148 << FixItHint::CreateInsertion(InsertionLoc: getLocForEndOfToken(Loc: FriendLoc),
18149 Code: InsertionText);
18150 } else {
18151 DiagCompat(Loc: FriendLoc, CompatDiagId: diag_compat::nonclass_type_friend)
18152 << T << DS.getSourceRange();
18153 }
18154 }
18155
18156 // C++98 [class.friend]p1: A friend of a class is a function
18157 // or class that is not a member of the class . . .
18158 // This is fixed in DR77, which just barely didn't make the C++03
18159 // deadline. It's also a very silly restriction that seriously
18160 // affects inner classes and which nobody else seems to implement;
18161 // thus we never diagnose it, not even in -pedantic.
18162 //
18163 // But note that we could warn about it: it's always useless to
18164 // friend one of your own members (it's not, however, worthless to
18165 // friend a member of an arbitrary specialization of your template).
18166
18167 Decl *D;
18168 if (!TempParams.empty())
18169 // TODO: Support variadic friend template decls?
18170 D = FriendTemplateDecl::Create(Context, DC: CurContext, Loc, Params: TempParams, Friend: TSI,
18171 FriendLoc);
18172 else
18173 D = FriendDecl::Create(C&: Context, DC: CurContext, L: TSI->getTypeLoc().getBeginLoc(),
18174 Friend_: TSI, FriendL: FriendLoc, EllipsisLoc);
18175
18176 if (!D)
18177 return nullptr;
18178
18179 D->setAccess(AS_public);
18180 CurContext->addDecl(D);
18181
18182 if (Invalid)
18183 D->setInvalidDecl();
18184
18185 return D;
18186}
18187
18188NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
18189 MultiTemplateParamsArg TemplateParams) {
18190 const DeclSpec &DS = D.getDeclSpec();
18191
18192 assert(DS.isFriendSpecified());
18193 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
18194
18195 SourceLocation Loc = D.getIdentifierLoc();
18196 TypeSourceInfo *TInfo = GetTypeForDeclarator(D);
18197
18198 // C++ [class.friend]p1
18199 // A friend of a class is a function or class....
18200 // Note that this sees through typedefs, which is intended.
18201 // It *doesn't* see through dependent types, which is correct
18202 // according to [temp.arg.type]p3:
18203 // If a declaration acquires a function type through a
18204 // type dependent on a template-parameter and this causes
18205 // a declaration that does not use the syntactic form of a
18206 // function declarator to have a function type, the program
18207 // is ill-formed.
18208 if (!TInfo->getType()->isFunctionType()) {
18209 Diag(Loc, DiagID: diag::err_unexpected_friend);
18210
18211 // It might be worthwhile to try to recover by creating an
18212 // appropriate declaration.
18213 return nullptr;
18214 }
18215
18216 // C++ [namespace.memdef]p3
18217 // - If a friend declaration in a non-local class first declares a
18218 // class or function, the friend class or function is a member
18219 // of the innermost enclosing namespace.
18220 // - The name of the friend is not found by simple name lookup
18221 // until a matching declaration is provided in that namespace
18222 // scope (either before or after the class declaration granting
18223 // friendship).
18224 // - If a friend function is called, its name may be found by the
18225 // name lookup that considers functions from namespaces and
18226 // classes associated with the types of the function arguments.
18227 // - When looking for a prior declaration of a class or a function
18228 // declared as a friend, scopes outside the innermost enclosing
18229 // namespace scope are not considered.
18230
18231 CXXScopeSpec &SS = D.getCXXScopeSpec();
18232 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
18233 assert(NameInfo.getName());
18234
18235 // Check for unexpanded parameter packs.
18236 if (DiagnoseUnexpandedParameterPack(Loc, T: TInfo, UPPC: UPPC_FriendDeclaration) ||
18237 DiagnoseUnexpandedParameterPack(NameInfo, UPPC: UPPC_FriendDeclaration) ||
18238 DiagnoseUnexpandedParameterPack(SS, UPPC: UPPC_FriendDeclaration))
18239 return nullptr;
18240
18241 // The context we found the declaration in, or in which we should
18242 // create the declaration.
18243 DeclContext *DC;
18244 Scope *DCScope = S;
18245 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
18246 RedeclarationKind::ForExternalRedeclaration);
18247
18248 bool isTemplateId = D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId;
18249
18250 // There are five cases here.
18251 // - There's no scope specifier and we're in a local class. Only look
18252 // for functions declared in the immediately-enclosing block scope.
18253 // We recover from invalid scope qualifiers as if they just weren't there.
18254 FunctionDecl *FunctionContainingLocalClass = nullptr;
18255 if ((SS.isInvalid() || !SS.isSet()) &&
18256 (FunctionContainingLocalClass =
18257 cast<CXXRecordDecl>(Val: CurContext)->isLocalClass())) {
18258 // C++11 [class.friend]p11:
18259 // If a friend declaration appears in a local class and the name
18260 // specified is an unqualified name, a prior declaration is
18261 // looked up without considering scopes that are outside the
18262 // innermost enclosing non-class scope. For a friend function
18263 // declaration, if there is no prior declaration, the program is
18264 // ill-formed.
18265
18266 // Find the innermost enclosing non-class scope. This is the block
18267 // scope containing the local class definition (or for a nested class,
18268 // the outer local class).
18269 DCScope = S->getFnParent();
18270
18271 // Look up the function name in the scope.
18272 Previous.clear(Kind: LookupLocalFriendName);
18273 LookupName(R&: Previous, S, /*AllowBuiltinCreation*/false);
18274
18275 if (!Previous.empty()) {
18276 // All possible previous declarations must have the same context:
18277 // either they were declared at block scope or they are members of
18278 // one of the enclosing local classes.
18279 DC = Previous.getRepresentativeDecl()->getDeclContext();
18280 } else {
18281 // This is ill-formed, but provide the context that we would have
18282 // declared the function in, if we were permitted to, for error recovery.
18283 DC = FunctionContainingLocalClass;
18284 }
18285 adjustContextForLocalExternDecl(DC);
18286
18287 // - There's no scope specifier, in which case we just go to the
18288 // appropriate scope and look for a function or function template
18289 // there as appropriate.
18290 } else if (SS.isInvalid() || !SS.isSet()) {
18291 // C++11 [namespace.memdef]p3:
18292 // If the name in a friend declaration is neither qualified nor
18293 // a template-id and the declaration is a function or an
18294 // elaborated-type-specifier, the lookup to determine whether
18295 // the entity has been previously declared shall not consider
18296 // any scopes outside the innermost enclosing namespace.
18297
18298 // Find the appropriate context according to the above.
18299 DC = CurContext;
18300
18301 // Skip class contexts. If someone can cite chapter and verse
18302 // for this behavior, that would be nice --- it's what GCC and
18303 // EDG do, and it seems like a reasonable intent, but the spec
18304 // really only says that checks for unqualified existing
18305 // declarations should stop at the nearest enclosing namespace,
18306 // not that they should only consider the nearest enclosing
18307 // namespace.
18308 while (DC->isRecord())
18309 DC = DC->getParent();
18310
18311 DeclContext *LookupDC = DC->getNonTransparentContext();
18312 while (true) {
18313 LookupQualifiedName(R&: Previous, LookupCtx: LookupDC);
18314
18315 if (!Previous.empty()) {
18316 DC = LookupDC;
18317 break;
18318 }
18319
18320 if (isTemplateId) {
18321 if (isa<TranslationUnitDecl>(Val: LookupDC)) break;
18322 } else {
18323 if (LookupDC->isFileContext()) break;
18324 }
18325 LookupDC = LookupDC->getParent();
18326 }
18327
18328 DCScope = getScopeForDeclContext(S, DC);
18329
18330 // - There's a non-dependent scope specifier, in which case we
18331 // compute it and do a previous lookup there for a function
18332 // or function template.
18333 } else if (!SS.getScopeRep().isDependent()) {
18334 DC = computeDeclContext(SS);
18335 if (!DC) return nullptr;
18336
18337 if (RequireCompleteDeclContext(SS, DC)) return nullptr;
18338
18339 LookupQualifiedName(R&: Previous, LookupCtx: DC);
18340
18341 // C++ [class.friend]p1: A friend of a class is a function or
18342 // class that is not a member of the class . . .
18343 if (DC->Equals(DC: CurContext))
18344 Diag(Loc: DS.getFriendSpecLoc(),
18345 DiagID: getLangOpts().CPlusPlus11 ?
18346 diag::warn_cxx98_compat_friend_is_member :
18347 diag::err_friend_is_member);
18348
18349 // - There's a scope specifier that does not match any template
18350 // parameter lists, in which case we use some arbitrary context,
18351 // create a method or method template, and wait for instantiation.
18352 // - There's a scope specifier that does match some template
18353 // parameter lists, which we don't handle right now.
18354 } else {
18355 DC = CurContext;
18356 assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
18357 }
18358
18359 if (!DC->isRecord()) {
18360 int DiagArg = -1;
18361 switch (D.getName().getKind()) {
18362 case UnqualifiedIdKind::IK_ConstructorTemplateId:
18363 case UnqualifiedIdKind::IK_ConstructorName:
18364 DiagArg = 0;
18365 break;
18366 case UnqualifiedIdKind::IK_DestructorName:
18367 DiagArg = 1;
18368 break;
18369 case UnqualifiedIdKind::IK_ConversionFunctionId:
18370 DiagArg = 2;
18371 break;
18372 case UnqualifiedIdKind::IK_DeductionGuideName:
18373 DiagArg = 3;
18374 break;
18375 case UnqualifiedIdKind::IK_Identifier:
18376 case UnqualifiedIdKind::IK_ImplicitSelfParam:
18377 case UnqualifiedIdKind::IK_LiteralOperatorId:
18378 case UnqualifiedIdKind::IK_OperatorFunctionId:
18379 case UnqualifiedIdKind::IK_TemplateId:
18380 break;
18381 }
18382 // This implies that it has to be an operator or function.
18383 if (DiagArg >= 0) {
18384 Diag(Loc, DiagID: diag::err_introducing_special_friend) << DiagArg;
18385 return nullptr;
18386 }
18387 }
18388
18389 // FIXME: This is an egregious hack to cope with cases where the scope stack
18390 // does not contain the declaration context, i.e., in an out-of-line
18391 // definition of a class.
18392 Scope FakeDCScope(S, Scope::DeclScope, Diags);
18393 if (!DCScope) {
18394 FakeDCScope.setEntity(DC);
18395 DCScope = &FakeDCScope;
18396 }
18397
18398 bool AddToScope = true;
18399 NamedDecl *ND = ActOnFunctionDeclarator(S: DCScope, D, DC, TInfo, Previous,
18400 TemplateParamLists: TemplateParams, AddToScope);
18401 if (!ND) return nullptr;
18402
18403 assert(ND->getLexicalDeclContext() == CurContext);
18404
18405 // If we performed typo correction, we might have added a scope specifier
18406 // and changed the decl context.
18407 DC = ND->getDeclContext();
18408
18409 // Add the function declaration to the appropriate lookup tables,
18410 // adjusting the redeclarations list as necessary. We don't
18411 // want to do this yet if the friending class is dependent.
18412 //
18413 // Also update the scope-based lookup if the target context's
18414 // lookup context is in lexical scope.
18415 if (!CurContext->isDependentContext()) {
18416 DC = DC->getRedeclContext();
18417 DC->makeDeclVisibleInContext(D: ND);
18418 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
18419 PushOnScopeChains(D: ND, S: EnclosingScope, /*AddToContext=*/ false);
18420 }
18421
18422 FriendDecl *FrD = FriendDecl::Create(C&: Context, DC: CurContext,
18423 L: D.getIdentifierLoc(), Friend_: ND,
18424 FriendL: DS.getFriendSpecLoc());
18425 FrD->setAccess(AS_public);
18426 CurContext->addDecl(D: FrD);
18427
18428 if (ND->isInvalidDecl()) {
18429 FrD->setInvalidDecl();
18430 } else {
18431 if (DC->isRecord()) CheckFriendAccess(D: ND);
18432
18433 FunctionDecl *FD;
18434 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(Val: ND))
18435 FD = FTD->getTemplatedDecl();
18436 else
18437 FD = cast<FunctionDecl>(Val: ND);
18438
18439 // C++ [class.friend]p6:
18440 // A function may be defined in a friend declaration of a class if and
18441 // only if the class is a non-local class, and the function name is
18442 // unqualified.
18443 if (D.isFunctionDefinition()) {
18444 // Qualified friend function definition.
18445 if (SS.isNotEmpty()) {
18446 // FIXME: We should only do this if the scope specifier names the
18447 // innermost enclosing namespace; otherwise the fixit changes the
18448 // meaning of the code.
18449 SemaDiagnosticBuilder DB =
18450 Diag(Loc: SS.getRange().getBegin(), DiagID: diag::err_qualified_friend_def);
18451
18452 DB << SS.getScopeRep();
18453 if (DC->isFileContext())
18454 DB << FixItHint::CreateRemoval(RemoveRange: SS.getRange());
18455
18456 // Friend function defined in a local class.
18457 } else if (FunctionContainingLocalClass) {
18458 Diag(Loc: NameInfo.getBeginLoc(), DiagID: diag::err_friend_def_in_local_class);
18459
18460 // Per [basic.pre]p4, a template-id is not a name. Therefore, if we have
18461 // a template-id, the function name is not unqualified because these is
18462 // no name. While the wording requires some reading in-between the
18463 // lines, GCC, MSVC, and EDG all consider a friend function
18464 // specialization definitions to be de facto explicit specialization
18465 // and diagnose them as such.
18466 } else if (isTemplateId) {
18467 Diag(Loc: NameInfo.getBeginLoc(), DiagID: diag::err_friend_specialization_def);
18468 }
18469 }
18470
18471 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
18472 // default argument expression, that declaration shall be a definition
18473 // and shall be the only declaration of the function or function
18474 // template in the translation unit.
18475 if (functionDeclHasDefaultArgument(FD)) {
18476 // We can't look at FD->getPreviousDecl() because it may not have been set
18477 // if we're in a dependent context. If the function is known to be a
18478 // redeclaration, we will have narrowed Previous down to the right decl.
18479 if (D.isRedeclaration()) {
18480 Diag(Loc: FD->getLocation(), DiagID: diag::err_friend_decl_with_def_arg_redeclared);
18481 Diag(Loc: Previous.getRepresentativeDecl()->getLocation(),
18482 DiagID: diag::note_previous_declaration);
18483 } else if (!D.isFunctionDefinition())
18484 Diag(Loc: FD->getLocation(), DiagID: diag::err_friend_decl_with_def_arg_must_be_def);
18485 }
18486
18487 // Mark templated-scope function declarations as unsupported.
18488 if (FD->getNumTemplateParameterLists() && SS.isValid()) {
18489 Diag(Loc: FD->getLocation(), DiagID: diag::warn_template_qualified_friend_unsupported)
18490 << SS.getScopeRep() << SS.getRange()
18491 << cast<CXXRecordDecl>(Val: CurContext);
18492 FrD->setUnsupportedFriend(true);
18493 }
18494 }
18495
18496 warnOnReservedIdentifier(D: ND);
18497
18498 return ND;
18499}
18500
18501void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc,
18502 StringLiteral *Message) {
18503 AdjustDeclIfTemplate(Decl&: Dcl);
18504
18505 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Val: Dcl);
18506 if (!Fn) {
18507 Diag(Loc: DelLoc, DiagID: diag::err_deleted_non_function);
18508 return;
18509 }
18510
18511 // Deleted function does not have a body.
18512 Fn->setWillHaveBody(false);
18513
18514 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
18515 // Don't consider the implicit declaration we generate for explicit
18516 // specializations. FIXME: Do not generate these implicit declarations.
18517 if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
18518 Prev->getPreviousDecl()) &&
18519 !Prev->isDefined()) {
18520 Diag(Loc: DelLoc, DiagID: diag::err_deleted_decl_not_first);
18521 Diag(Loc: Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
18522 DiagID: Prev->isImplicit() ? diag::note_previous_implicit_declaration
18523 : diag::note_previous_declaration);
18524 // We can't recover from this; the declaration might have already
18525 // been used.
18526 Fn->setInvalidDecl();
18527 return;
18528 }
18529
18530 // To maintain the invariant that functions are only deleted on their first
18531 // declaration, mark the implicitly-instantiated declaration of the
18532 // explicitly-specialized function as deleted instead of marking the
18533 // instantiated redeclaration.
18534 Fn = Fn->getCanonicalDecl();
18535 }
18536
18537 // dllimport/dllexport cannot be deleted.
18538 if (const InheritableAttr *DLLAttr = getDLLAttr(D: Fn)) {
18539 Diag(Loc: Fn->getLocation(), DiagID: diag::err_attribute_dll_deleted) << DLLAttr;
18540 Fn->setInvalidDecl();
18541 }
18542
18543 // C++11 [basic.start.main]p3:
18544 // A program that defines main as deleted [...] is ill-formed.
18545 if (Fn->isMain())
18546 Diag(Loc: DelLoc, DiagID: diag::err_deleted_main);
18547
18548 // C++11 [dcl.fct.def.delete]p4:
18549 // A deleted function is implicitly inline.
18550 Fn->setImplicitlyInline();
18551 Fn->setDeletedAsWritten(D: true, Message);
18552}
18553
18554void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
18555 if (!Dcl || Dcl->isInvalidDecl())
18556 return;
18557
18558 auto *FD = dyn_cast<FunctionDecl>(Val: Dcl);
18559 if (!FD) {
18560 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Val: Dcl)) {
18561 if (getDefaultedFunctionKind(FD: FTD->getTemplatedDecl()).isComparison()) {
18562 Diag(Loc: DefaultLoc, DiagID: diag::err_defaulted_comparison_template);
18563 return;
18564 }
18565 }
18566
18567 Diag(Loc: DefaultLoc, DiagID: diag::err_default_special_members)
18568 << getLangOpts().CPlusPlus20;
18569 return;
18570 }
18571
18572 // Reject if this can't possibly be a defaultable function.
18573 DefaultedFunctionKind DefKind = getDefaultedFunctionKind(FD);
18574 if (!DefKind &&
18575 // A dependent function that doesn't locally look defaultable can
18576 // still instantiate to a defaultable function if it's a constructor
18577 // or assignment operator.
18578 (!FD->isDependentContext() ||
18579 (!isa<CXXConstructorDecl>(Val: FD) &&
18580 FD->getDeclName().getCXXOverloadedOperator() != OO_Equal))) {
18581 Diag(Loc: DefaultLoc, DiagID: diag::err_default_special_members)
18582 << getLangOpts().CPlusPlus20;
18583 return;
18584 }
18585
18586 // Issue compatibility warning. We already warned if the operator is
18587 // 'operator<=>' when parsing the '<=>' token.
18588 if (DefKind.isComparison() &&
18589 DefKind.asComparison() != DefaultedComparisonKind::ThreeWay) {
18590 Diag(Loc: DefaultLoc, DiagID: getLangOpts().CPlusPlus20
18591 ? diag::warn_cxx17_compat_defaulted_comparison
18592 : diag::ext_defaulted_comparison);
18593 }
18594
18595 FD->setDefaulted();
18596 FD->setExplicitlyDefaulted();
18597 FD->setDefaultLoc(DefaultLoc);
18598
18599 // Defer checking functions that are defaulted in a dependent context.
18600 if (FD->isDependentContext())
18601 return;
18602
18603 // Unset that we will have a body for this function. We might not,
18604 // if it turns out to be trivial, and we don't need this marking now
18605 // that we've marked it as defaulted.
18606 FD->setWillHaveBody(false);
18607
18608 if (DefKind.isComparison()) {
18609 // If this comparison's defaulting occurs within the definition of its
18610 // lexical class context, we have to do the checking when complete.
18611 if (auto const *RD = dyn_cast<CXXRecordDecl>(Val: FD->getLexicalDeclContext()))
18612 if (!RD->isCompleteDefinition())
18613 return;
18614 }
18615
18616 // If this member fn was defaulted on its first declaration, we will have
18617 // already performed the checking in CheckCompletedCXXClass. Such a
18618 // declaration doesn't trigger an implicit definition.
18619 if (isa<CXXMethodDecl>(Val: FD)) {
18620 const FunctionDecl *Primary = FD;
18621 if (const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
18622 // Ask the template instantiation pattern that actually had the
18623 // '= default' on it.
18624 Primary = Pattern;
18625 if (Primary->getCanonicalDecl()->isDefaulted())
18626 return;
18627 }
18628
18629 if (DefKind.isComparison()) {
18630 if (CheckExplicitlyDefaultedComparison(S: nullptr, FD, DCK: DefKind.asComparison()))
18631 FD->setInvalidDecl();
18632 else
18633 DefineDefaultedComparison(UseLoc: DefaultLoc, FD, DCK: DefKind.asComparison());
18634 } else {
18635 auto *MD = cast<CXXMethodDecl>(Val: FD);
18636
18637 if (CheckExplicitlyDefaultedSpecialMember(MD, CSM: DefKind.asSpecialMember(),
18638 DefaultLoc))
18639 MD->setInvalidDecl();
18640 else
18641 DefineDefaultedFunction(S&: *this, FD: MD, DefaultLoc);
18642 }
18643}
18644
18645static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
18646 for (Stmt *SubStmt : S->children()) {
18647 if (!SubStmt)
18648 continue;
18649 if (isa<ReturnStmt>(Val: SubStmt))
18650 Self.Diag(Loc: SubStmt->getBeginLoc(),
18651 DiagID: diag::err_return_in_constructor_handler);
18652 if (!isa<Expr>(Val: SubStmt))
18653 SearchForReturnInStmt(Self, S: SubStmt);
18654 }
18655}
18656
18657void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
18658 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
18659 CXXCatchStmt *Handler = TryBlock->getHandler(i: I);
18660 SearchForReturnInStmt(Self&: *this, S: Handler);
18661 }
18662}
18663
18664void Sema::SetFunctionBodyKind(Decl *D, SourceLocation Loc, FnBodyKind BodyKind,
18665 StringLiteral *DeletedMessage) {
18666 switch (BodyKind) {
18667 case FnBodyKind::Delete:
18668 SetDeclDeleted(Dcl: D, DelLoc: Loc, Message: DeletedMessage);
18669 break;
18670 case FnBodyKind::Default:
18671 SetDeclDefaulted(Dcl: D, DefaultLoc: Loc);
18672 break;
18673 case FnBodyKind::Other:
18674 llvm_unreachable(
18675 "Parsed function body should be '= delete;' or '= default;'");
18676 }
18677}
18678
18679bool Sema::CheckOverridingFunctionAttributes(CXXMethodDecl *New,
18680 const CXXMethodDecl *Old) {
18681 const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
18682 const auto *OldFT = Old->getType()->castAs<FunctionProtoType>();
18683
18684 if (OldFT->hasExtParameterInfos()) {
18685 for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
18686 // A parameter of the overriding method should be annotated with noescape
18687 // if the corresponding parameter of the overridden method is annotated.
18688 if (OldFT->getExtParameterInfo(I).isNoEscape() &&
18689 !NewFT->getExtParameterInfo(I).isNoEscape()) {
18690 Diag(Loc: New->getParamDecl(i: I)->getLocation(),
18691 DiagID: diag::warn_overriding_method_missing_noescape);
18692 Diag(Loc: Old->getParamDecl(i: I)->getLocation(),
18693 DiagID: diag::note_overridden_marked_noescape);
18694 }
18695 }
18696
18697 // SME attributes must match when overriding a function declaration.
18698 if (IsInvalidSMECallConversion(FromType: Old->getType(), ToType: New->getType())) {
18699 Diag(Loc: New->getLocation(), DiagID: diag::err_conflicting_overriding_attributes)
18700 << New << New->getType() << Old->getType();
18701 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function);
18702 return true;
18703 }
18704
18705 // Virtual overrides must have the same code_seg.
18706 const auto *OldCSA = Old->getAttr<CodeSegAttr>();
18707 const auto *NewCSA = New->getAttr<CodeSegAttr>();
18708 if ((NewCSA || OldCSA) &&
18709 (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
18710 Diag(Loc: New->getLocation(), DiagID: diag::err_mismatched_code_seg_override);
18711 Diag(Loc: Old->getLocation(), DiagID: diag::note_previous_declaration);
18712 return true;
18713 }
18714
18715 // Virtual overrides: check for matching effects.
18716 if (Context.hasAnyFunctionEffects()) {
18717 const auto OldFX = Old->getFunctionEffects();
18718 const auto NewFXOrig = New->getFunctionEffects();
18719
18720 if (OldFX != NewFXOrig) {
18721 FunctionEffectSet NewFX(NewFXOrig);
18722 const auto Diffs = FunctionEffectDiffVector(OldFX, NewFX);
18723 FunctionEffectSet::Conflicts Errs;
18724 for (const auto &Diff : Diffs) {
18725 switch (Diff.shouldDiagnoseMethodOverride(OldMethod: *Old, OldFX, NewMethod: *New, NewFX)) {
18726 case FunctionEffectDiff::OverrideResult::NoAction:
18727 break;
18728 case FunctionEffectDiff::OverrideResult::Warn:
18729 Diag(Loc: New->getLocation(), DiagID: diag::warn_conflicting_func_effect_override)
18730 << Diff.effectName();
18731 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function)
18732 << Old->getReturnTypeSourceRange();
18733 break;
18734 case FunctionEffectDiff::OverrideResult::Merge: {
18735 NewFX.insert(NewEC: Diff.Old.value(), Errs);
18736 const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
18737 FunctionProtoType::ExtProtoInfo EPI = NewFT->getExtProtoInfo();
18738 EPI.FunctionEffects = FunctionEffectsRef(NewFX);
18739 QualType ModQT = Context.getFunctionType(ResultTy: NewFT->getReturnType(),
18740 Args: NewFT->getParamTypes(), EPI);
18741 New->setType(ModQT);
18742 if (Errs.empty()) {
18743 // A warning here is somewhat pedantic. Skip this if there was
18744 // already a merge conflict, which is more serious.
18745 Diag(Loc: New->getLocation(), DiagID: diag::warn_mismatched_func_effect_override)
18746 << Diff.effectName();
18747 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function)
18748 << Old->getReturnTypeSourceRange();
18749 }
18750 break;
18751 }
18752 }
18753 }
18754 if (!Errs.empty())
18755 diagnoseFunctionEffectMergeConflicts(Errs, NewLoc: New->getLocation(),
18756 OldLoc: Old->getLocation());
18757 }
18758 }
18759
18760 CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
18761
18762 // If the calling conventions match, everything is fine
18763 if (NewCC == OldCC)
18764 return false;
18765
18766 // If the calling conventions mismatch because the new function is static,
18767 // suppress the calling convention mismatch error; the error about static
18768 // function override (err_static_overrides_virtual from
18769 // Sema::CheckFunctionDeclaration) is more clear.
18770 if (New->getStorageClass() == SC_Static)
18771 return false;
18772
18773 Diag(Loc: New->getLocation(),
18774 DiagID: diag::err_conflicting_overriding_cc_attributes)
18775 << New->getDeclName() << New->getType() << Old->getType();
18776 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function);
18777 return true;
18778}
18779
18780bool Sema::CheckExplicitObjectOverride(CXXMethodDecl *New,
18781 const CXXMethodDecl *Old) {
18782 // CWG2553
18783 // A virtual function shall not be an explicit object member function.
18784 if (!New->isExplicitObjectMemberFunction())
18785 return true;
18786 Diag(Loc: New->getParamDecl(i: 0)->getBeginLoc(),
18787 DiagID: diag::err_explicit_object_parameter_nonmember)
18788 << New->getSourceRange() << /*virtual*/ 1 << /*IsLambda*/ false;
18789 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function);
18790 New->setInvalidDecl();
18791 return false;
18792}
18793
18794bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
18795 const CXXMethodDecl *Old) {
18796 QualType NewTy = New->getType()->castAs<FunctionType>()->getReturnType();
18797 QualType OldTy = Old->getType()->castAs<FunctionType>()->getReturnType();
18798
18799 if (Context.hasSameType(T1: NewTy, T2: OldTy) ||
18800 NewTy->isDependentType() || OldTy->isDependentType())
18801 return false;
18802
18803 // Check if the return types are covariant
18804 QualType NewClassTy, OldClassTy;
18805
18806 /// Both types must be pointers or references to classes.
18807 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
18808 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
18809 NewClassTy = NewPT->getPointeeType();
18810 OldClassTy = OldPT->getPointeeType();
18811 }
18812 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
18813 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
18814 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
18815 NewClassTy = NewRT->getPointeeType();
18816 OldClassTy = OldRT->getPointeeType();
18817 }
18818 }
18819 }
18820
18821 // The return types aren't either both pointers or references to a class type.
18822 if (NewClassTy.isNull() || !NewClassTy->isStructureOrClassType()) {
18823 Diag(Loc: New->getLocation(),
18824 DiagID: diag::err_different_return_type_for_overriding_virtual_function)
18825 << New->getDeclName() << NewTy << OldTy
18826 << New->getReturnTypeSourceRange();
18827 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function)
18828 << Old->getReturnTypeSourceRange();
18829
18830 return true;
18831 }
18832
18833 if (!Context.hasSameUnqualifiedType(T1: NewClassTy, T2: OldClassTy)) {
18834 // C++14 [class.virtual]p8:
18835 // If the class type in the covariant return type of D::f differs from
18836 // that of B::f, the class type in the return type of D::f shall be
18837 // complete at the point of declaration of D::f or shall be the class
18838 // type D.
18839 if (const auto *RD = NewClassTy->getAsCXXRecordDecl()) {
18840 if (!RD->isBeingDefined() &&
18841 RequireCompleteType(Loc: New->getLocation(), T: NewClassTy,
18842 DiagID: diag::err_covariant_return_incomplete,
18843 Args: New->getDeclName()))
18844 return true;
18845 }
18846
18847 // Check if the new class derives from the old class.
18848 if (!IsDerivedFrom(Loc: New->getLocation(), Derived: NewClassTy, Base: OldClassTy)) {
18849 Diag(Loc: New->getLocation(), DiagID: diag::err_covariant_return_not_derived)
18850 << New->getDeclName() << NewTy << OldTy
18851 << New->getReturnTypeSourceRange();
18852 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function)
18853 << Old->getReturnTypeSourceRange();
18854 return true;
18855 }
18856
18857 // Check if we the conversion from derived to base is valid.
18858 if (CheckDerivedToBaseConversion(
18859 Derived: NewClassTy, Base: OldClassTy,
18860 InaccessibleBaseID: diag::err_covariant_return_inaccessible_base,
18861 AmbiguousBaseConvID: diag::err_covariant_return_ambiguous_derived_to_base_conv,
18862 Loc: New->getLocation(), Range: New->getReturnTypeSourceRange(),
18863 Name: New->getDeclName(), BasePath: nullptr)) {
18864 // FIXME: this note won't trigger for delayed access control
18865 // diagnostics, and it's impossible to get an undelayed error
18866 // here from access control during the original parse because
18867 // the ParsingDeclSpec/ParsingDeclarator are still in scope.
18868 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function)
18869 << Old->getReturnTypeSourceRange();
18870 return true;
18871 }
18872 }
18873
18874 // The qualifiers of the return types must be the same.
18875 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
18876 Diag(Loc: New->getLocation(),
18877 DiagID: diag::err_covariant_return_type_different_qualifications)
18878 << New->getDeclName() << NewTy << OldTy
18879 << New->getReturnTypeSourceRange();
18880 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function)
18881 << Old->getReturnTypeSourceRange();
18882 return true;
18883 }
18884
18885
18886 // The new class type must have the same or less qualifiers as the old type.
18887 if (!OldClassTy.isAtLeastAsQualifiedAs(other: NewClassTy, Ctx: getASTContext())) {
18888 Diag(Loc: New->getLocation(),
18889 DiagID: diag::err_covariant_return_type_class_type_not_same_or_less_qualified)
18890 << New->getDeclName() << NewTy << OldTy
18891 << New->getReturnTypeSourceRange();
18892 Diag(Loc: Old->getLocation(), DiagID: diag::note_overridden_virtual_function)
18893 << Old->getReturnTypeSourceRange();
18894 return true;
18895 }
18896
18897 return false;
18898}
18899
18900bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
18901 SourceLocation EndLoc = InitRange.getEnd();
18902 if (EndLoc.isValid())
18903 Method->setRangeEnd(EndLoc);
18904
18905 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
18906 Method->setIsPureVirtual();
18907 return false;
18908 }
18909
18910 if (!Method->isInvalidDecl())
18911 Diag(Loc: Method->getLocation(), DiagID: diag::err_non_virtual_pure)
18912 << Method->getDeclName() << InitRange;
18913 return true;
18914}
18915
18916void Sema::ActOnPureSpecifier(Decl *D, SourceLocation ZeroLoc) {
18917 if (D->getFriendObjectKind())
18918 Diag(Loc: D->getLocation(), DiagID: diag::err_pure_friend);
18919 else if (auto *M = dyn_cast<CXXMethodDecl>(Val: D))
18920 CheckPureMethod(Method: M, InitRange: ZeroLoc);
18921 else
18922 Diag(Loc: D->getLocation(), DiagID: diag::err_illegal_initializer);
18923}
18924
18925/// Invoked when we are about to parse an initializer for the declaration
18926/// 'Dcl'.
18927///
18928/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
18929/// static data member of class X, names should be looked up in the scope of
18930/// class X. If the declaration had a scope specifier, a scope will have
18931/// been created and passed in for this purpose. Otherwise, S will be null.
18932void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
18933 assert(D && !D->isInvalidDecl());
18934
18935 // We will always have a nested name specifier here, but this declaration
18936 // might not be out of line if the specifier names the current namespace:
18937 // extern int n;
18938 // int ::n = 0;
18939 if (S && D->isOutOfLine())
18940 EnterDeclaratorContext(S, DC: D->getDeclContext());
18941
18942 PushExpressionEvaluationContext(
18943 NewContext: ExpressionEvaluationContext::PotentiallyEvaluated, LambdaContextDecl: D,
18944 Type: ExpressionEvaluationContextRecord::EK_VariableInit);
18945}
18946
18947void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
18948 assert(D);
18949
18950 if (S && D->isOutOfLine())
18951 ExitDeclaratorContext(S);
18952
18953 PopExpressionEvaluationContext();
18954}
18955
18956DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
18957 // C++ 6.4p2:
18958 // The declarator shall not specify a function or an array.
18959 // The type-specifier-seq shall not contain typedef and shall not declare a
18960 // new class or enumeration.
18961 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
18962 "Parser allowed 'typedef' as storage class of condition decl.");
18963
18964 Decl *Dcl = ActOnDeclarator(S, D);
18965 if (!Dcl)
18966 return true;
18967
18968 if (isa<FunctionDecl>(Val: Dcl)) { // The declarator shall not specify a function.
18969 Diag(Loc: Dcl->getLocation(), DiagID: diag::err_invalid_use_of_function_type)
18970 << D.getSourceRange();
18971 return true;
18972 }
18973
18974 if (auto *VD = dyn_cast<VarDecl>(Val: Dcl))
18975 VD->setCXXCondDecl();
18976
18977 return Dcl;
18978}
18979
18980void Sema::LoadExternalVTableUses() {
18981 if (!ExternalSource)
18982 return;
18983
18984 SmallVector<ExternalVTableUse, 4> VTables;
18985 ExternalSource->ReadUsedVTables(VTables);
18986 SmallVector<VTableUse, 4> NewUses;
18987 for (const ExternalVTableUse &VTable : VTables) {
18988 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos =
18989 VTablesUsed.find(Val: VTable.Record);
18990 // Even if a definition wasn't required before, it may be required now.
18991 if (Pos != VTablesUsed.end()) {
18992 if (!Pos->second && VTable.DefinitionRequired)
18993 Pos->second = true;
18994 continue;
18995 }
18996
18997 VTablesUsed[VTable.Record] = VTable.DefinitionRequired;
18998 NewUses.push_back(Elt: VTableUse(VTable.Record, VTable.Location));
18999 }
19000
19001 VTableUses.insert(I: VTableUses.begin(), From: NewUses.begin(), To: NewUses.end());
19002}
19003
19004void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
19005 bool DefinitionRequired) {
19006 // Ignore any vtable uses in unevaluated operands or for classes that do
19007 // not have a vtable.
19008 if (!Class->isDynamicClass() || Class->isDependentContext() ||
19009 CurContext->isDependentContext() || isUnevaluatedContext())
19010 return;
19011 // Do not mark as used if compiling for the device outside of the target
19012 // region.
19013 if (TUKind != TU_Prefix && LangOpts.OpenMP && LangOpts.OpenMPIsTargetDevice &&
19014 !OpenMP().isInOpenMPDeclareTargetContext() &&
19015 !OpenMP().isInOpenMPTargetExecutionDirective()) {
19016 if (!DefinitionRequired)
19017 MarkVirtualMembersReferenced(Loc, RD: Class);
19018 return;
19019 }
19020
19021 // Try to insert this class into the map.
19022 LoadExternalVTableUses();
19023 Class = Class->getCanonicalDecl();
19024 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
19025 Pos = VTablesUsed.insert(KV: std::make_pair(x&: Class, y&: DefinitionRequired));
19026 if (!Pos.second) {
19027 // If we already had an entry, check to see if we are promoting this vtable
19028 // to require a definition. If so, we need to reappend to the VTableUses
19029 // list, since we may have already processed the first entry.
19030 if (DefinitionRequired && !Pos.first->second) {
19031 Pos.first->second = true;
19032 } else {
19033 // Otherwise, we can early exit.
19034 return;
19035 }
19036 } else {
19037 // The Microsoft ABI requires that we perform the destructor body
19038 // checks (i.e. operator delete() lookup) when the vtable is marked used, as
19039 // the deleting destructor is emitted with the vtable, not with the
19040 // destructor definition as in the Itanium ABI.
19041 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
19042 CXXDestructorDecl *DD = Class->getDestructor();
19043 if (DD && DD->isVirtual() && !DD->isDeleted()) {
19044 if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
19045 // If this is an out-of-line declaration, marking it referenced will
19046 // not do anything. Manually call CheckDestructor to look up operator
19047 // delete().
19048 ContextRAII SavedContext(*this, DD);
19049 CheckDestructor(Destructor: DD);
19050 } else {
19051 MarkFunctionReferenced(Loc, Func: Class->getDestructor());
19052 }
19053 }
19054 }
19055 }
19056
19057 // Local classes need to have their virtual members marked
19058 // immediately. For all other classes, we mark their virtual members
19059 // at the end of the translation unit.
19060 if (Class->isLocalClass())
19061 MarkVirtualMembersReferenced(Loc, RD: Class->getDefinition());
19062 else
19063 VTableUses.push_back(Elt: std::make_pair(x&: Class, y&: Loc));
19064}
19065
19066bool Sema::DefineUsedVTables() {
19067 LoadExternalVTableUses();
19068 if (VTableUses.empty())
19069 return false;
19070
19071 // Note: The VTableUses vector could grow as a result of marking
19072 // the members of a class as "used", so we check the size each
19073 // time through the loop and prefer indices (which are stable) to
19074 // iterators (which are not).
19075 bool DefinedAnything = false;
19076 for (unsigned I = 0; I != VTableUses.size(); ++I) {
19077 CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
19078 if (!Class)
19079 continue;
19080 TemplateSpecializationKind ClassTSK =
19081 Class->getTemplateSpecializationKind();
19082
19083 SourceLocation Loc = VTableUses[I].second;
19084
19085 bool DefineVTable = true;
19086
19087 const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(RD: Class);
19088 // V-tables for non-template classes with an owning module are always
19089 // uniquely emitted in that module.
19090 if (Class->isInCurrentModuleUnit()) {
19091 DefineVTable = true;
19092 } else if (KeyFunction && !KeyFunction->hasBody()) {
19093 // If this class has a key function, but that key function is
19094 // defined in another translation unit, we don't need to emit the
19095 // vtable even though we're using it.
19096 // The key function is in another translation unit.
19097 DefineVTable = false;
19098 TemplateSpecializationKind TSK =
19099 KeyFunction->getTemplateSpecializationKind();
19100 assert(TSK != TSK_ExplicitInstantiationDefinition &&
19101 TSK != TSK_ImplicitInstantiation &&
19102 "Instantiations don't have key functions");
19103 (void)TSK;
19104 } else if (!KeyFunction) {
19105 // If we have a class with no key function that is the subject
19106 // of an explicit instantiation declaration, suppress the
19107 // vtable; it will live with the explicit instantiation
19108 // definition.
19109 bool IsExplicitInstantiationDeclaration =
19110 ClassTSK == TSK_ExplicitInstantiationDeclaration;
19111 for (auto *R : Class->redecls()) {
19112 TemplateSpecializationKind TSK
19113 = cast<CXXRecordDecl>(Val: R)->getTemplateSpecializationKind();
19114 if (TSK == TSK_ExplicitInstantiationDeclaration)
19115 IsExplicitInstantiationDeclaration = true;
19116 else if (TSK == TSK_ExplicitInstantiationDefinition) {
19117 IsExplicitInstantiationDeclaration = false;
19118 break;
19119 }
19120 }
19121
19122 if (IsExplicitInstantiationDeclaration)
19123 DefineVTable = false;
19124 }
19125
19126 // The exception specifications for all virtual members may be needed even
19127 // if we are not providing an authoritative form of the vtable in this TU.
19128 // We may choose to emit it available_externally anyway.
19129 if (!DefineVTable) {
19130 MarkVirtualMemberExceptionSpecsNeeded(Loc, RD: Class);
19131 continue;
19132 }
19133
19134 // Mark all of the virtual members of this class as referenced, so
19135 // that we can build a vtable. Then, tell the AST consumer that a
19136 // vtable for this class is required.
19137 DefinedAnything = true;
19138 MarkVirtualMembersReferenced(Loc, RD: Class);
19139 CXXRecordDecl *Canonical = Class->getCanonicalDecl();
19140 if (VTablesUsed[Canonical] && !Class->shouldEmitInExternalSource())
19141 Consumer.HandleVTable(RD: Class);
19142
19143 // Warn if we're emitting a weak vtable. The vtable will be weak if there is
19144 // no key function or the key function is inlined. Don't warn in C++ ABIs
19145 // that lack key functions, since the user won't be able to make one.
19146 if (Context.getTargetInfo().getCXXABI().hasKeyFunctions() &&
19147 Class->isExternallyVisible() && ClassTSK != TSK_ImplicitInstantiation &&
19148 ClassTSK != TSK_ExplicitInstantiationDefinition) {
19149 const FunctionDecl *KeyFunctionDef = nullptr;
19150 if (!KeyFunction || (KeyFunction->hasBody(Definition&: KeyFunctionDef) &&
19151 KeyFunctionDef->isInlined()))
19152 Diag(Loc: Class->getLocation(), DiagID: diag::warn_weak_vtable) << Class;
19153 }
19154 }
19155 VTableUses.clear();
19156
19157 return DefinedAnything;
19158}
19159
19160void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
19161 const CXXRecordDecl *RD) {
19162 for (const auto *I : RD->methods())
19163 if (I->isVirtual() && !I->isPureVirtual())
19164 ResolveExceptionSpec(Loc, FPT: I->getType()->castAs<FunctionProtoType>());
19165}
19166
19167void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
19168 const CXXRecordDecl *RD,
19169 bool ConstexprOnly) {
19170 // Mark all functions which will appear in RD's vtable as used.
19171 CXXFinalOverriderMap FinalOverriders;
19172 RD->getFinalOverriders(FinaOverriders&: FinalOverriders);
19173 for (const auto &FinalOverrider : FinalOverriders) {
19174 for (const auto &OverridingMethod : FinalOverrider.second) {
19175 assert(OverridingMethod.second.size() > 0 && "no final overrider");
19176 CXXMethodDecl *Overrider = OverridingMethod.second.front().Method;
19177
19178 // C++ [basic.def.odr]p2:
19179 // [...] A virtual member function is used if it is not pure. [...]
19180 if (!Overrider->isPureVirtual() &&
19181 (!ConstexprOnly || Overrider->isConstexpr()))
19182 MarkFunctionReferenced(Loc, Func: Overrider);
19183 }
19184 }
19185
19186 // Only classes that have virtual bases need a VTT.
19187 if (RD->getNumVBases() == 0)
19188 return;
19189
19190 for (const auto &I : RD->bases()) {
19191 const auto *Base = I.getType()->castAsCXXRecordDecl();
19192 if (Base->getNumVBases() == 0)
19193 continue;
19194 MarkVirtualMembersReferenced(Loc, RD: Base);
19195 }
19196}
19197
19198static
19199void DelegatingCycleHelper(CXXConstructorDecl* Ctor,
19200 llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Valid,
19201 llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Invalid,
19202 llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Current,
19203 Sema &S) {
19204 if (Ctor->isInvalidDecl())
19205 return;
19206
19207 CXXConstructorDecl *Target = Ctor->getTargetConstructor();
19208
19209 // Target may not be determinable yet, for instance if this is a dependent
19210 // call in an uninstantiated template.
19211 if (Target) {
19212 const FunctionDecl *FNTarget = nullptr;
19213 (void)Target->hasBody(Definition&: FNTarget);
19214 Target = const_cast<CXXConstructorDecl*>(
19215 cast_or_null<CXXConstructorDecl>(Val: FNTarget));
19216 }
19217
19218 CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
19219 // Avoid dereferencing a null pointer here.
19220 *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
19221
19222 if (!Current.insert(Ptr: Canonical).second)
19223 return;
19224
19225 // We know that beyond here, we aren't chaining into a cycle.
19226 if (!Target || !Target->isDelegatingConstructor() ||
19227 Target->isInvalidDecl() || Valid.count(Ptr: TCanonical)) {
19228 Valid.insert_range(R&: Current);
19229 Current.clear();
19230 // We've hit a cycle.
19231 } else if (TCanonical == Canonical || Invalid.count(Ptr: TCanonical) ||
19232 Current.count(Ptr: TCanonical)) {
19233 // If we haven't diagnosed this cycle yet, do so now.
19234 if (!Invalid.count(Ptr: TCanonical)) {
19235 S.Diag(Loc: (*Ctor->init_begin())->getSourceLocation(),
19236 DiagID: diag::warn_delegating_ctor_cycle)
19237 << Ctor;
19238
19239 // Don't add a note for a function delegating directly to itself.
19240 if (TCanonical != Canonical)
19241 S.Diag(Loc: Target->getLocation(), DiagID: diag::note_it_delegates_to);
19242
19243 CXXConstructorDecl *C = Target;
19244 while (C->getCanonicalDecl() != Canonical) {
19245 const FunctionDecl *FNTarget = nullptr;
19246 (void)C->getTargetConstructor()->hasBody(Definition&: FNTarget);
19247 assert(FNTarget && "Ctor cycle through bodiless function");
19248
19249 C = const_cast<CXXConstructorDecl*>(
19250 cast<CXXConstructorDecl>(Val: FNTarget));
19251 S.Diag(Loc: C->getLocation(), DiagID: diag::note_which_delegates_to);
19252 }
19253 }
19254
19255 Invalid.insert_range(R&: Current);
19256 Current.clear();
19257 } else {
19258 DelegatingCycleHelper(Ctor: Target, Valid, Invalid, Current, S);
19259 }
19260}
19261
19262
19263void Sema::CheckDelegatingCtorCycles() {
19264 llvm::SmallPtrSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
19265
19266 for (DelegatingCtorDeclsType::iterator
19267 I = DelegatingCtorDecls.begin(source: ExternalSource.get()),
19268 E = DelegatingCtorDecls.end();
19269 I != E; ++I)
19270 DelegatingCycleHelper(Ctor: *I, Valid, Invalid, Current, S&: *this);
19271
19272 for (CXXConstructorDecl *CI : Invalid)
19273 CI->setInvalidDecl();
19274}
19275
19276namespace {
19277 /// AST visitor that finds references to the 'this' expression.
19278class FindCXXThisExpr : public DynamicRecursiveASTVisitor {
19279 Sema &S;
19280
19281public:
19282 explicit FindCXXThisExpr(Sema &S) : S(S) {}
19283
19284 bool VisitCXXThisExpr(CXXThisExpr *E) override {
19285 S.Diag(Loc: E->getLocation(), DiagID: diag::err_this_static_member_func)
19286 << E->isImplicit();
19287 return false;
19288 }
19289};
19290}
19291
19292bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) {
19293 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
19294 if (!TSInfo)
19295 return false;
19296
19297 TypeLoc TL = TSInfo->getTypeLoc();
19298 FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
19299 if (!ProtoTL)
19300 return false;
19301
19302 // C++11 [expr.prim.general]p3:
19303 // [The expression this] shall not appear before the optional
19304 // cv-qualifier-seq and it shall not appear within the declaration of a
19305 // static member function (although its type and value category are defined
19306 // within a static member function as they are within a non-static member
19307 // function). [ Note: this is because declaration matching does not occur
19308 // until the complete declarator is known. - end note ]
19309 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
19310 FindCXXThisExpr Finder(*this);
19311
19312 // If the return type came after the cv-qualifier-seq, check it now.
19313 if (Proto->hasTrailingReturn() &&
19314 !Finder.TraverseTypeLoc(TL: ProtoTL.getReturnLoc()))
19315 return true;
19316
19317 // Check the exception specification.
19318 if (checkThisInStaticMemberFunctionExceptionSpec(Method))
19319 return true;
19320
19321 // Check the trailing requires clause
19322 if (const AssociatedConstraint &TRC = Method->getTrailingRequiresClause())
19323 if (!Finder.TraverseStmt(S: const_cast<Expr *>(TRC.ConstraintExpr)))
19324 return true;
19325
19326 return checkThisInStaticMemberFunctionAttributes(Method);
19327}
19328
19329bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) {
19330 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
19331 if (!TSInfo)
19332 return false;
19333
19334 TypeLoc TL = TSInfo->getTypeLoc();
19335 FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
19336 if (!ProtoTL)
19337 return false;
19338
19339 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
19340 FindCXXThisExpr Finder(*this);
19341
19342 switch (Proto->getExceptionSpecType()) {
19343 case EST_Unparsed:
19344 case EST_Uninstantiated:
19345 case EST_Unevaluated:
19346 case EST_BasicNoexcept:
19347 case EST_NoThrow:
19348 case EST_DynamicNone:
19349 case EST_MSAny:
19350 case EST_None:
19351 break;
19352
19353 case EST_DependentNoexcept:
19354 case EST_NoexceptFalse:
19355 case EST_NoexceptTrue:
19356 if (!Finder.TraverseStmt(S: Proto->getNoexceptExpr()))
19357 return true;
19358 [[fallthrough]];
19359
19360 case EST_Dynamic:
19361 for (const auto &E : Proto->exceptions()) {
19362 if (!Finder.TraverseType(T: E))
19363 return true;
19364 }
19365 break;
19366 }
19367
19368 return false;
19369}
19370
19371bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) {
19372 FindCXXThisExpr Finder(*this);
19373
19374 // Check attributes.
19375 for (const auto *A : Method->attrs()) {
19376 // FIXME: This should be emitted by tblgen.
19377 Expr *Arg = nullptr;
19378 ArrayRef<Expr *> Args;
19379 if (const auto *G = dyn_cast<GuardedByAttr>(Val: A))
19380 Arg = G->getArg();
19381 else if (const auto *G = dyn_cast<PtGuardedByAttr>(Val: A))
19382 Arg = G->getArg();
19383 else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(Val: A))
19384 Args = llvm::ArrayRef(AA->args_begin(), AA->args_size());
19385 else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(Val: A))
19386 Args = llvm::ArrayRef(AB->args_begin(), AB->args_size());
19387 else if (const auto *LR = dyn_cast<LockReturnedAttr>(Val: A))
19388 Arg = LR->getArg();
19389 else if (const auto *LE = dyn_cast<LocksExcludedAttr>(Val: A))
19390 Args = llvm::ArrayRef(LE->args_begin(), LE->args_size());
19391 else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(Val: A))
19392 Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
19393 else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(Val: A))
19394 Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
19395 else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(Val: A)) {
19396 Arg = AC->getSuccessValue();
19397 Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
19398 } else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(Val: A))
19399 Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
19400
19401 if (Arg && !Finder.TraverseStmt(S: Arg))
19402 return true;
19403
19404 for (Expr *A : Args) {
19405 if (!Finder.TraverseStmt(S: A))
19406 return true;
19407 }
19408 }
19409
19410 return false;
19411}
19412
19413void Sema::checkExceptionSpecification(
19414 bool IsTopLevel, ExceptionSpecificationType EST,
19415 ArrayRef<ParsedType> DynamicExceptions,
19416 ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
19417 SmallVectorImpl<QualType> &Exceptions,
19418 FunctionProtoType::ExceptionSpecInfo &ESI) {
19419 Exceptions.clear();
19420 ESI.Type = EST;
19421 if (EST == EST_Dynamic) {
19422 Exceptions.reserve(N: DynamicExceptions.size());
19423 for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
19424 // FIXME: Preserve type source info.
19425 QualType ET = GetTypeFromParser(Ty: DynamicExceptions[ei]);
19426
19427 if (IsTopLevel) {
19428 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
19429 collectUnexpandedParameterPacks(T: ET, Unexpanded);
19430 if (!Unexpanded.empty()) {
19431 DiagnoseUnexpandedParameterPacks(
19432 Loc: DynamicExceptionRanges[ei].getBegin(), UPPC: UPPC_ExceptionType,
19433 Unexpanded);
19434 continue;
19435 }
19436 }
19437
19438 // Check that the type is valid for an exception spec, and
19439 // drop it if not.
19440 if (!CheckSpecifiedExceptionType(T&: ET, Range: DynamicExceptionRanges[ei]))
19441 Exceptions.push_back(Elt: ET);
19442 }
19443 ESI.Exceptions = Exceptions;
19444 return;
19445 }
19446
19447 if (isComputedNoexcept(ESpecType: EST)) {
19448 assert((NoexceptExpr->isTypeDependent() ||
19449 NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
19450 Context.BoolTy) &&
19451 "Parser should have made sure that the expression is boolean");
19452 if (IsTopLevel && DiagnoseUnexpandedParameterPack(E: NoexceptExpr)) {
19453 ESI.Type = EST_BasicNoexcept;
19454 return;
19455 }
19456
19457 ESI.NoexceptExpr = NoexceptExpr;
19458 return;
19459 }
19460}
19461
19462void Sema::actOnDelayedExceptionSpecification(
19463 Decl *D, ExceptionSpecificationType EST, SourceRange SpecificationRange,
19464 ArrayRef<ParsedType> DynamicExceptions,
19465 ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr) {
19466 if (!D)
19467 return;
19468
19469 // Dig out the function we're referring to.
19470 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(Val: D))
19471 D = FTD->getTemplatedDecl();
19472
19473 FunctionDecl *FD = dyn_cast<FunctionDecl>(Val: D);
19474 if (!FD)
19475 return;
19476
19477 // Check the exception specification.
19478 llvm::SmallVector<QualType, 4> Exceptions;
19479 FunctionProtoType::ExceptionSpecInfo ESI;
19480 checkExceptionSpecification(/*IsTopLevel=*/true, EST, DynamicExceptions,
19481 DynamicExceptionRanges, NoexceptExpr, Exceptions,
19482 ESI);
19483
19484 // Update the exception specification on the function type.
19485 Context.adjustExceptionSpec(FD, ESI, /*AsWritten=*/true);
19486
19487 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: D)) {
19488 if (MD->isStatic())
19489 checkThisInStaticMemberFunctionExceptionSpec(Method: MD);
19490
19491 if (MD->isVirtual()) {
19492 // Check overrides, which we previously had to delay.
19493 for (const CXXMethodDecl *O : MD->overridden_methods())
19494 CheckOverridingFunctionExceptionSpec(New: MD, Old: O);
19495 }
19496 }
19497}
19498
19499/// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
19500///
19501MSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record,
19502 SourceLocation DeclStart, Declarator &D,
19503 Expr *BitWidth,
19504 InClassInitStyle InitStyle,
19505 AccessSpecifier AS,
19506 const ParsedAttr &MSPropertyAttr) {
19507 const IdentifierInfo *II = D.getIdentifier();
19508 if (!II) {
19509 Diag(Loc: DeclStart, DiagID: diag::err_anonymous_property);
19510 return nullptr;
19511 }
19512 SourceLocation Loc = D.getIdentifierLoc();
19513
19514 TypeSourceInfo *TInfo = GetTypeForDeclarator(D);
19515 QualType T = TInfo->getType();
19516 if (getLangOpts().CPlusPlus) {
19517 CheckExtraCXXDefaultArguments(D);
19518
19519 if (DiagnoseUnexpandedParameterPack(Loc: D.getIdentifierLoc(), T: TInfo,
19520 UPPC: UPPC_DataMemberType)) {
19521 D.setInvalidType();
19522 T = Context.IntTy;
19523 TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
19524 }
19525 }
19526
19527 DiagnoseFunctionSpecifiers(DS: D.getDeclSpec());
19528
19529 if (D.getDeclSpec().isInlineSpecified())
19530 Diag(Loc: D.getDeclSpec().getInlineSpecLoc(), DiagID: diag::err_inline_non_function)
19531 << getLangOpts().CPlusPlus17;
19532 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
19533 Diag(Loc: D.getDeclSpec().getThreadStorageClassSpecLoc(),
19534 DiagID: diag::err_invalid_thread)
19535 << DeclSpec::getSpecifierName(S: TSCS);
19536
19537 // Check to see if this name was declared as a member previously
19538 NamedDecl *PrevDecl = nullptr;
19539 LookupResult Previous(*this, II, Loc, LookupMemberName,
19540 RedeclarationKind::ForVisibleRedeclaration);
19541 LookupName(R&: Previous, S);
19542 switch (Previous.getResultKind()) {
19543 case LookupResultKind::Found:
19544 case LookupResultKind::FoundUnresolvedValue:
19545 PrevDecl = Previous.getAsSingle<NamedDecl>();
19546 break;
19547
19548 case LookupResultKind::FoundOverloaded:
19549 PrevDecl = Previous.getRepresentativeDecl();
19550 break;
19551
19552 case LookupResultKind::NotFound:
19553 case LookupResultKind::NotFoundInCurrentInstantiation:
19554 case LookupResultKind::Ambiguous:
19555 break;
19556 }
19557
19558 if (PrevDecl && PrevDecl->isTemplateParameter()) {
19559 // Maybe we will complain about the shadowed template parameter.
19560 DiagnoseTemplateParameterShadow(Loc: D.getIdentifierLoc(), PrevDecl);
19561 // Just pretend that we didn't see the previous declaration.
19562 PrevDecl = nullptr;
19563 }
19564
19565 if (PrevDecl && !isDeclInScope(D: PrevDecl, Ctx: Record, S))
19566 PrevDecl = nullptr;
19567
19568 SourceLocation TSSL = D.getBeginLoc();
19569 MSPropertyDecl *NewPD =
19570 MSPropertyDecl::Create(C&: Context, DC: Record, L: Loc, N: II, T, TInfo, StartL: TSSL,
19571 Getter: MSPropertyAttr.getPropertyDataGetter(),
19572 Setter: MSPropertyAttr.getPropertyDataSetter());
19573 ProcessDeclAttributes(S: TUScope, D: NewPD, PD: D);
19574 NewPD->setAccess(AS);
19575
19576 if (NewPD->isInvalidDecl())
19577 Record->setInvalidDecl();
19578
19579 if (D.getDeclSpec().isModulePrivateSpecified())
19580 NewPD->setModulePrivate();
19581
19582 if (NewPD->isInvalidDecl() && PrevDecl) {
19583 // Don't introduce NewFD into scope; there's already something
19584 // with the same name in the same scope.
19585 } else if (II) {
19586 PushOnScopeChains(D: NewPD, S);
19587 } else
19588 Record->addDecl(D: NewPD);
19589
19590 return NewPD;
19591}
19592
19593void Sema::ActOnStartFunctionDeclarationDeclarator(
19594 Declarator &Declarator, unsigned TemplateParameterDepth) {
19595 auto &Info = InventedParameterInfos.emplace_back();
19596 TemplateParameterList *ExplicitParams = nullptr;
19597 ArrayRef<TemplateParameterList *> ExplicitLists =
19598 Declarator.getTemplateParameterLists();
19599 if (!ExplicitLists.empty()) {
19600 bool IsMemberSpecialization, IsInvalid;
19601 ExplicitParams = MatchTemplateParametersToScopeSpecifier(
19602 DeclStartLoc: Declarator.getBeginLoc(), DeclLoc: Declarator.getIdentifierLoc(),
19603 SS: Declarator.getCXXScopeSpec(), /*TemplateId=*/nullptr,
19604 ParamLists: ExplicitLists, /*IsFriend=*/false, IsMemberSpecialization, Invalid&: IsInvalid,
19605 /*SuppressDiagnostic=*/true);
19606 }
19607 // C++23 [dcl.fct]p23:
19608 // An abbreviated function template can have a template-head. The invented
19609 // template-parameters are appended to the template-parameter-list after
19610 // the explicitly declared template-parameters.
19611 //
19612 // A template-head must have one or more template-parameters (read:
19613 // 'template<>' is *not* a template-head). Only append the invented
19614 // template parameters if we matched the nested-name-specifier to a non-empty
19615 // TemplateParameterList.
19616 if (ExplicitParams && !ExplicitParams->empty()) {
19617 Info.AutoTemplateParameterDepth = ExplicitParams->getDepth();
19618 llvm::append_range(C&: Info.TemplateParams, R&: *ExplicitParams);
19619 Info.NumExplicitTemplateParams = ExplicitParams->size();
19620 } else {
19621 Info.AutoTemplateParameterDepth = TemplateParameterDepth;
19622 Info.NumExplicitTemplateParams = 0;
19623 }
19624}
19625
19626void Sema::ActOnFinishFunctionDeclarationDeclarator(Declarator &Declarator) {
19627 auto &FSI = InventedParameterInfos.back();
19628 if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
19629 if (FSI.NumExplicitTemplateParams != 0) {
19630 TemplateParameterList *ExplicitParams =
19631 Declarator.getTemplateParameterLists().back();
19632 Declarator.setInventedTemplateParameterList(
19633 TemplateParameterList::Create(
19634 C: Context, TemplateLoc: ExplicitParams->getTemplateLoc(),
19635 LAngleLoc: ExplicitParams->getLAngleLoc(), Params: FSI.TemplateParams,
19636 RAngleLoc: ExplicitParams->getRAngleLoc(),
19637 RequiresClause: ExplicitParams->getRequiresClause()));
19638 } else {
19639 Declarator.setInventedTemplateParameterList(TemplateParameterList::Create(
19640 C: Context, TemplateLoc: Declarator.getBeginLoc(), LAngleLoc: SourceLocation(),
19641 Params: FSI.TemplateParams, RAngleLoc: Declarator.getEndLoc(),
19642 /*RequiresClause=*/nullptr));
19643 }
19644 }
19645 InventedParameterInfos.pop_back();
19646}
19647