conforming GNU extensions. Projects incompatible with C++17 can add
``-std=gnu++14`` to their build settings to restore the previous behaviour.
- Implemented DR2358 allowing init captures in lambdas in default arguments.
-- Implemented DR2631. Invalid ``consteval`` calls in default arguments and default
- member initializers are diagnosed when and if the default is used.
- This Fixes `Issue 56379 <https://github.com/llvm/llvm-project/issues/56379>`_
- and changes the value of ``std::source_location::current()``
- used in default parameters calls compared to previous versions of Clang.
C++20 Feature Support
^^^^^^^^^^^^^^^^^^^^^
/// This wraps up a function call argument that was created from the
/// corresponding parameter's default argument, when the call did not
/// explicitly supply arguments for all of the parameters.
-class CXXDefaultArgExpr final
- : public Expr,
- private llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {
+class CXXDefaultArgExpr final : public Expr {
friend class ASTStmtReader;
- friend class ASTReader;
- friend TrailingObjects;
/// The parameter whose default is being used.
ParmVarDecl *Param;
DeclContext *UsedContext;
CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
- Expr *RewrittenExpr, DeclContext *UsedContext)
+ DeclContext *UsedContext)
: Expr(SC,
Param->hasUnparsedDefaultArg()
? Param->getType().getNonReferenceType()
Param->getDefaultArg()->getObjectKind()),
Param(Param), UsedContext(UsedContext) {
CXXDefaultArgExprBits.Loc = Loc;
- CXXDefaultArgExprBits.HasRewrittenInit = RewrittenExpr != nullptr;
- if (RewrittenExpr)
- *getTrailingObjects<Expr *>() = RewrittenExpr;
setDependence(computeDependence(this));
}
- CXXDefaultArgExpr(EmptyShell Empty, bool HasRewrittenInit)
- : Expr(CXXDefaultArgExprClass, Empty) {
- CXXDefaultArgExprBits.HasRewrittenInit = HasRewrittenInit;
- }
-
- size_t numTrailingObjects() const {
- return CXXDefaultArgExprBits.HasRewrittenInit;
- }
-
public:
- static CXXDefaultArgExpr *CreateEmpty(const ASTContext &C,
- bool HasRewrittenInit);
+ CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
// \p Param is the parameter whose default argument is used by this
// expression.
static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
- ParmVarDecl *Param, Expr *RewrittenExpr,
- DeclContext *UsedContext);
+ ParmVarDecl *Param,
+ DeclContext *UsedContext) {
+ return new (C)
+ CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, UsedContext);
+ }
+
// Retrieve the parameter that the argument was created from.
const ParmVarDecl *getParam() const { return Param; }
ParmVarDecl *getParam() { return Param; }
- bool hasRewrittenInit() const {
- return CXXDefaultArgExprBits.HasRewrittenInit;
- }
-
- // Retrieve the argument to the function call.
- Expr *getExpr();
- const Expr *getExpr() const {
- return const_cast<CXXDefaultArgExpr *>(this)->getExpr();
- }
-
- Expr *getRewrittenExpr() {
- return hasRewrittenInit() ? *getTrailingObjects<Expr *>() : nullptr;
- }
-
- const Expr *getRewrittenExpr() const {
- return const_cast<CXXDefaultArgExpr *>(this)->getRewrittenExpr();
- }
-
- // Retrieve the rewritten init expression (for an init expression containing
- // immediate calls) with the top level FullExpr and ConstantExpr stripped off.
- Expr *getAdjustedRewrittenExpr();
- const Expr *getAdjustedRewrittenExpr() const {
- return const_cast<CXXDefaultArgExpr *>(this)->getAdjustedRewrittenExpr();
- }
+ // Retrieve the actual argument to the function call.
+ const Expr *getExpr() const { return getParam()->getDefaultArg(); }
+ Expr *getExpr() { return getParam()->getDefaultArg(); }
const DeclContext *getUsedContext() const { return UsedContext; }
DeclContext *getUsedContext() { return UsedContext; }
/// is implicitly used in a mem-initializer-list in a constructor
/// (C++11 [class.base.init]p8) or in aggregate initialization
/// (C++1y [dcl.init.aggr]p7).
-class CXXDefaultInitExpr final
- : public Expr,
- private llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {
-
- friend class ASTStmtReader;
+class CXXDefaultInitExpr : public Expr {
friend class ASTReader;
- friend TrailingObjects;
+ friend class ASTStmtReader;
+
/// The field whose default is being used.
FieldDecl *Field;
DeclContext *UsedContext;
CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc,
- FieldDecl *Field, QualType Ty, DeclContext *UsedContext,
- Expr *RewrittenInitExpr);
-
- CXXDefaultInitExpr(EmptyShell Empty, bool HasRewrittenInit)
- : Expr(CXXDefaultInitExprClass, Empty) {
- CXXDefaultInitExprBits.HasRewrittenInit = HasRewrittenInit;
- }
+ FieldDecl *Field, QualType Ty, DeclContext *UsedContext);
- size_t numTrailingObjects() const {
- return CXXDefaultInitExprBits.HasRewrittenInit;
- }
+ CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}
public:
- static CXXDefaultInitExpr *CreateEmpty(const ASTContext &C,
- bool HasRewrittenInit);
/// \p Field is the non-static data member whose default initializer is used
/// by this expression.
static CXXDefaultInitExpr *Create(const ASTContext &Ctx, SourceLocation Loc,
- FieldDecl *Field, DeclContext *UsedContext,
- Expr *RewrittenInitExpr);
-
- bool hasRewrittenInit() const {
- return CXXDefaultInitExprBits.HasRewrittenInit;
+ FieldDecl *Field, DeclContext *UsedContext) {
+ return new (Ctx) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(), UsedContext);
}
/// Get the field whose initializer will be used.
const FieldDecl *getField() const { return Field; }
/// Get the initialization expression that will be used.
- Expr *getExpr();
const Expr *getExpr() const {
- return const_cast<CXXDefaultInitExpr *>(this)->getExpr();
- }
-
- /// Retrieve the initializing expression with evaluated immediate calls, if
- /// any.
- const Expr *getRewrittenExpr() const {
- assert(hasRewrittenInit() && "expected a rewritten init expression");
- return *getTrailingObjects<Expr *>();
+ assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
+ return Field->getInClassInitializer();
}
-
- /// Retrieve the initializing expression with evaluated immediate calls, if
- /// any.
- Expr *getRewrittenExpr() {
- assert(hasRewrittenInit() && "expected a rewritten init expression");
- return *getTrailingObjects<Expr *>();
+ Expr *getExpr() {
+ assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
+ return Field->getInClassInitializer();
}
const DeclContext *getUsedContext() const { return UsedContext; }
unsigned : NumExprBits;
- /// Whether this CXXDefaultArgExpr rewrote its argument and stores a copy.
- unsigned HasRewrittenInit : 1;
-
/// The location where the default argument expression was used.
SourceLocation Loc;
};
unsigned : NumExprBits;
- /// Whether this CXXDefaultInitExprBitfields rewrote its argument and stores
- /// a copy.
- unsigned HasRewrittenInit : 1;
-
/// The location where the default initializer expression was used.
SourceLocation Loc;
};
" of an immediate invocation">;
def err_invalid_consteval_call : Error<
"call to consteval function %q0 is not a constant expression">;
-def note_invalid_consteval_initializer : Note<
- "in the default initalizer of %0">;
-def note_invalid_consteval_initializer_here : Note<
- "initialized here %0">;
def err_invalid_consteval_decl_kind : Error<
"%0 cannot be declared consteval">;
def err_invalid_constexpr : Error<
bool InDiscardedStatement;
bool InImmediateFunctionContext;
- bool IsCurrentlyCheckingDefaultArgumentOrInitializer = false;
-
- // When evaluating immediate functions in the initializer of a default
- // argument or default member initializer, this is the declaration whose
- // default initializer is being evaluated and the location of the call
- // or constructor definition.
- struct InitializationContext {
- InitializationContext(SourceLocation Loc, ValueDecl *Decl,
- DeclContext *Context)
- : Loc(Loc), Decl(Decl), Context(Context) {
- assert(Decl && Context && "invalid initialization context");
- };
-
- SourceLocation Loc;
- ValueDecl *Decl = nullptr;
- DeclContext *Context = nullptr;
- };
- llvm::Optional<InitializationContext> DelayedDefaultInitializationContext;
-
ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
unsigned NumCleanupObjects,
CleanupInfo ParentCleanup,
bool IsStdInitListInitialization, bool RequiresZeroInit,
unsigned ConstructKind, SourceRange ParenRange);
- ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr,
- SourceLocation InitLoc);
-
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
/// Instantiate or parse a C++ default argument expression as necessary.
/// Return true on error.
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
- ParmVarDecl *Param, Expr *Init = nullptr,
- bool SkipImmediateInvocations = true);
+ ParmVarDecl *Param);
/// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
/// the default expr if needed.
- ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
- ParmVarDecl *Param, Expr *Init = nullptr);
+ ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
+ FunctionDecl *FD,
+ ParmVarDecl *Param);
/// FinalizeVarWithDestructor - Prepare for calling destructor on the
/// constructed variable.
return ExprEvalContexts.back().isImmediateFunctionContext();
}
- bool isCheckingDefaultArgumentOrInitializer() const {
- assert(!ExprEvalContexts.empty() &&
- "Must be in an expression evaluation context");
- const ExpressionEvaluationContextRecord &Ctx = ExprEvalContexts.back();
- return (Ctx.Context ==
- ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed) ||
- Ctx.IsCurrentlyCheckingDefaultArgumentOrInitializer;
- }
-
- bool isCheckingDefaultArgumentOrInitializerOfOuterEntity() const {
- assert(!ExprEvalContexts.empty() &&
- "Must be in an expression evaluation context");
- for (const auto &Ctx : llvm::reverse(ExprEvalContexts)) {
- if ((Ctx.Context ==
- ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed) ||
- Ctx.IsCurrentlyCheckingDefaultArgumentOrInitializer)
- return true;
- if (Ctx.isConstantEvaluated() || Ctx.isImmediateFunctionContext() ||
- Ctx.isUnevaluated())
- return false;
- }
- return false;
- }
-
- llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
- InnermostDeclarationWithDelayedImmediateInvocations() const {
- assert(!ExprEvalContexts.empty() &&
- "Must be in an expression evaluation context");
- for (const auto &Ctx : llvm::reverse(ExprEvalContexts)) {
- if (Ctx.Context == ExpressionEvaluationContext::PotentiallyEvaluated &&
- Ctx.DelayedDefaultInitializationContext)
- return Ctx.DelayedDefaultInitializationContext;
- if (Ctx.isConstantEvaluated() || Ctx.isImmediateFunctionContext() ||
- Ctx.isUnevaluated())
- break;
- }
- return llvm::None;
- }
-
- llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
- OutermostDeclarationWithDelayedImmediateInvocations() const {
- assert(!ExprEvalContexts.empty() &&
- "Must be in an expression evaluation context");
- llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
- Res;
- for (auto &Ctx : llvm::reverse(ExprEvalContexts)) {
- if (Ctx.Context == ExpressionEvaluationContext::PotentiallyEvaluated &&
- !Ctx.DelayedDefaultInitializationContext && Res)
- break;
- if (Ctx.isConstantEvaluated() || Ctx.isImmediateFunctionContext() ||
- Ctx.isUnevaluated())
- break;
- Res = Ctx.DelayedDefaultInitializationContext;
- }
- return Res;
- }
-
/// RAII class used to determine whether SFINAE has
/// trapped any errors that occur during template argument
/// deduction.
if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
return std::move(Err);
}
- Expr *RewrittenInit = nullptr;
- if (E->hasRewrittenInit()) {
- ExpectedExpr ExprOrErr = import(E->getExpr());
- if (!ExprOrErr)
- return ExprOrErr.takeError();
- RewrittenInit = ExprOrErr.get();
- }
+
return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
- *ToParamOrErr, RewrittenInit,
- *UsedContextOrErr);
+ *ToParamOrErr, *UsedContextOrErr);
}
ExpectedStmt
ToField->setInClassInitializer(*ToInClassInitializerOrErr);
}
- Expr *RewrittenInit = nullptr;
- if (E->hasRewrittenInit()) {
- ExpectedExpr ExprOrErr = import(E->getExpr());
- if (!ExprOrErr)
- return ExprOrErr.takeError();
- RewrittenInit = ExprOrErr.get();
- }
-
return CXXDefaultInitExpr::Create(Importer.getToContext(), *ToBeginLocOrErr,
- ToField, *UsedContextOrErr, RewrittenInit);
+ ToField, *UsedContextOrErr);
}
ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
Expr *Arg = getInit();
if (auto *E = dyn_cast_or_null<FullExpr>(Arg))
- return E->getSubExpr();
+ if (!isa<ConstantExpr>(E))
+ return E->getSubExpr();
return Arg;
}
return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier();
}
-CXXDefaultArgExpr *CXXDefaultArgExpr::CreateEmpty(const ASTContext &C,
- bool HasRewrittenInit) {
- size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
- auto *Mem = C.Allocate(Size, alignof(CXXDefaultArgExpr));
- return new (Mem) CXXDefaultArgExpr(EmptyShell(), HasRewrittenInit);
-}
-
-CXXDefaultArgExpr *CXXDefaultArgExpr::Create(const ASTContext &C,
- SourceLocation Loc,
- ParmVarDecl *Param,
- Expr *RewrittenExpr,
- DeclContext *UsedContext) {
- size_t Size = totalSizeToAlloc<Expr *>(RewrittenExpr != nullptr);
- auto *Mem = C.Allocate(Size, alignof(CXXDefaultArgExpr));
- return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
- RewrittenExpr, UsedContext);
-}
-
-Expr *CXXDefaultArgExpr::getExpr() {
- return CXXDefaultArgExprBits.HasRewrittenInit ? getAdjustedRewrittenExpr()
- : getParam()->getDefaultArg();
-}
-
-Expr *CXXDefaultArgExpr::getAdjustedRewrittenExpr() {
- assert(hasRewrittenInit() &&
- "expected this CXXDefaultArgExpr to have a rewritten init.");
- Expr *Init = getRewrittenExpr();
- if (auto *E = dyn_cast_if_present<FullExpr>(Init))
- if (!isa<ConstantExpr>(E))
- return E->getSubExpr();
- return Init;
-}
-
CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,
SourceLocation Loc, FieldDecl *Field,
- QualType Ty, DeclContext *UsedContext,
- Expr *RewrittenInitExpr)
+ QualType Ty, DeclContext *UsedContext)
: Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
Ty->isLValueReferenceType() ? VK_LValue
: Ty->isRValueReferenceType() ? VK_XValue
/*FIXME*/ OK_Ordinary),
Field(Field), UsedContext(UsedContext) {
CXXDefaultInitExprBits.Loc = Loc;
- CXXDefaultInitExprBits.HasRewrittenInit = RewrittenInitExpr != nullptr;
-
- if (CXXDefaultInitExprBits.HasRewrittenInit)
- *getTrailingObjects<Expr *>() = RewrittenInitExpr;
-
assert(Field->hasInClassInitializer());
setDependence(computeDependence(this));
}
-CXXDefaultInitExpr *CXXDefaultInitExpr::CreateEmpty(const ASTContext &C,
- bool HasRewrittenInit) {
- size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
- auto *Mem = C.Allocate(Size, alignof(CXXDefaultInitExpr));
- return new (Mem) CXXDefaultInitExpr(EmptyShell(), HasRewrittenInit);
-}
-
-CXXDefaultInitExpr *CXXDefaultInitExpr::Create(const ASTContext &Ctx,
- SourceLocation Loc,
- FieldDecl *Field,
- DeclContext *UsedContext,
- Expr *RewrittenInitExpr) {
-
- size_t Size = totalSizeToAlloc<Expr *>(RewrittenInitExpr != nullptr);
- auto *Mem = Ctx.Allocate(Size, alignof(CXXDefaultArgExpr));
- return new (Mem) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(),
- UsedContext, RewrittenInitExpr);
-}
-
-Expr *CXXDefaultInitExpr::getExpr() {
- assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
- if (hasRewrittenInit())
- return getRewrittenExpr();
-
- return Field->getInClassInitializer();
-}
-
CXXTemporary *CXXTemporary::Create(const ASTContext &C,
const CXXDestructorDecl *Destructor) {
return new (C) CXXTemporary(Destructor);
Actions.ActOnStartCXXInClassMemberInitializer();
- // The initializer isn't actually potentially evaluated unless it is
- // used.
- EnterExpressionEvaluationContext Eval(
- Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed);
-
ExprResult Init = ParseCXXMemberInitializer(MI.Field, /*IsFunction=*/false,
EqualLoc);
"Data member initializer not starting with '=' or '{'");
EnterExpressionEvaluationContext Context(
- Actions,
- isa_and_present<FieldDecl>(D)
- ? Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed
- : Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
- D);
+ Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, D);
if (TryConsumeToken(tok::equal, EqualLoc)) {
if (Tok.is(tok::kw_delete)) {
// In principle, an initializer of '= delete p;' is legal, but it will
return ConstraintExpr;
}
-ExprResult Sema::ConvertMemberDefaultInitExpression(FieldDecl *FD,
- Expr *InitExpr,
- SourceLocation InitLoc) {
- InitializedEntity Entity =
- InitializedEntity::InitializeMemberFromDefaultMemberInitializer(FD);
- InitializationKind Kind =
- FD->getInClassInitStyle() == ICIS_ListInit
- ? InitializationKind::CreateDirectList(InitExpr->getBeginLoc(),
- InitExpr->getBeginLoc(),
- InitExpr->getEndLoc())
- : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
- InitializationSequence Seq(*this, Entity, Kind, InitExpr);
- return Seq.Perform(*this, Entity, Kind, InitExpr);
-}
-
/// This is invoked after parsing an in-class initializer for a
/// non-static C++ class member, and after instantiating an in-class initializer
/// in a class template. Such actions are deferred until the class is complete.
ExprResult Init = InitExpr;
if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
- Init = ConvertMemberDefaultInitExpression(FD, InitExpr, InitLoc);
+ InitializedEntity Entity =
+ InitializedEntity::InitializeMemberFromDefaultMemberInitializer(FD);
+ InitializationKind Kind =
+ FD->getInClassInitStyle() == ICIS_ListInit
+ ? InitializationKind::CreateDirectList(InitExpr->getBeginLoc(),
+ InitExpr->getBeginLoc(),
+ InitExpr->getEndLoc())
+ : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
+ InitializationSequence Seq(*this, Entity, Kind, InitExpr);
+ Init = Seq.Perform(*this, Entity, Kind, InitExpr);
if (Init.isInvalid()) {
FD->setInvalidDecl();
return;
Constructor);
}
+ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
+ assert(Field->hasInClassInitializer());
+
+ // If we already have the in-class initializer nothing needs to be done.
+ if (Field->getInClassInitializer())
+ return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
+
+ // If we might have already tried and failed to instantiate, don't try again.
+ if (Field->isInvalidDecl())
+ return ExprError();
+
+ // Maybe we haven't instantiated the in-class initializer. Go check the
+ // pattern FieldDecl to see if it has one.
+ CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
+
+ if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
+ CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
+ DeclContext::lookup_result Lookup =
+ ClassPattern->lookup(Field->getDeclName());
+
+ FieldDecl *Pattern = nullptr;
+ for (auto *L : Lookup) {
+ if (isa<FieldDecl>(L)) {
+ Pattern = cast<FieldDecl>(L);
+ break;
+ }
+ }
+ assert(Pattern && "We must have set the Pattern!");
+
+ if (!Pattern->hasInClassInitializer() ||
+ InstantiateInClassInitializer(Loc, Field, Pattern,
+ getTemplateInstantiationArgs(Field))) {
+ // Don't diagnose this again.
+ Field->setInvalidDecl();
+ return ExprError();
+ }
+ return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
+ }
+
+ // DR1351:
+ // If the brace-or-equal-initializer of a non-static data member
+ // invokes a defaulted default constructor of its class or of an
+ // enclosing class in a potentially evaluated subexpression, the
+ // program is ill-formed.
+ //
+ // This resolution is unworkable: the exception specification of the
+ // default constructor can be needed in an unevaluated context, in
+ // particular, in the operand of a noexcept-expression, and we can be
+ // unable to compute an exception specification for an enclosed class.
+ //
+ // Any attempt to resolve the exception specification of a defaulted default
+ // constructor before the initializer is lexically complete will ultimately
+ // come here at which point we can diagnose it.
+ RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
+ Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
+ << OutermostClass << Field;
+ Diag(Field->getEndLoc(),
+ diag::note_default_member_initializer_not_yet_parsed);
+ // Recover by marking the field invalid, unless we're in a SFINAE context.
+ if (!isSFINAEContext())
+ Field->setInvalidDecl();
+ return ExprError();
+}
+
void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
if (VD->isInvalidDecl()) return;
// If initializing the variable failed, don't also diagnose problems with
}
bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
- ParmVarDecl *Param, Expr *RewrittenInit,
- bool SkipImmediateInvocations) {
+ ParmVarDecl *Param) {
if (Param->hasUnparsedDefaultArg()) {
- assert(!RewrittenInit && "Should not have a rewritten init expression yet");
// If we've already cleared out the location for the default argument,
// that means we're parsing it right now.
if (!UnparsedDefaultArgLocs.count(Param)) {
return true;
}
- if (Param->hasUninstantiatedDefaultArg()) {
- assert(!RewrittenInit && "Should not have a rewitten init expression yet");
- if (InstantiateDefaultArgument(CallLoc, FD, Param))
- return true;
- }
+ if (Param->hasUninstantiatedDefaultArg() &&
+ InstantiateDefaultArgument(CallLoc, FD, Param))
+ return true;
- Expr *Init = RewrittenInit ? RewrittenInit : Param->getInit();
- assert(Init && "default argument but no initializer?");
+ assert(Param->hasInit() && "default argument but no initializer?");
// If the default expression creates temporaries, we need to
// push them to the current stack of expression temporaries so they'll
// bound temporaries; see the comment in PR5810.
// We don't need to do that with block decls, though, because
// blocks in default argument expression can never capture anything.
- if (auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(Init)) {
+ if (auto Init = dyn_cast<ExprWithCleanups>(Param->getInit())) {
// Set the "needs cleanups" bit regardless of whether there are
// any explicit objects.
- Cleanup.setExprNeedsCleanups(InitWithCleanup->cleanupsHaveSideEffects());
+ Cleanup.setExprNeedsCleanups(Init->cleanupsHaveSideEffects());
+
// Append all the objects to the cleanup list. Right now, this
// should always be a no-op, because blocks in default argument
// expressions should never be able to capture anything.
- assert(!InitWithCleanup->getNumObjects() &&
+ assert(!Init->getNumObjects() &&
"default argument expression has capturing blocks?");
}
+
+ // We already type-checked the argument, so we know it works.
+ // Just mark all of the declarations in this potentially-evaluated expression
+ // as being "referenced".
EnterExpressionEvaluationContext EvalContext(
*this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
- ExprEvalContexts.back().IsCurrentlyCheckingDefaultArgumentOrInitializer =
- SkipImmediateInvocations;
- MarkDeclarationsReferencedInExpr(Init, /*SkipLocalVariables*/ true);
+ MarkDeclarationsReferencedInExpr(Param->getDefaultArg(),
+ /*SkipLocalVariables=*/true);
return false;
}
-struct ImmediateCallVisitor : public RecursiveASTVisitor<ImmediateCallVisitor> {
- bool HasImmediateCalls = false;
-
- bool VisitCallExpr(CallExpr *E) {
- if (const FunctionDecl *FD = E->getDirectCallee())
- HasImmediateCalls |= FD->isConsteval();
- return RecursiveASTVisitor<ImmediateCallVisitor>::VisitStmt(E);
- }
-
- // SourceLocExpr are not immediate invocations
- // but CXXDefaultInitExpr/CXXDefaultArgExpr containing a SourceLocExpr
- // need to be rebuilt so that they refer to the correct SourceLocation and
- // DeclContext.
- bool VisitSourceLocExpr(SourceLocExpr *E) {
- HasImmediateCalls = true;
- return RecursiveASTVisitor<ImmediateCallVisitor>::VisitStmt(E);
- }
-
- // A nested lambda might have parameters with immediate invocations
- // in their default arguments.
- // The compound statement is not visited (as it does not constitute a
- // subexpression).
- // FIXME: We should consider visiting and transforming captures
- // with init expressions.
- bool VisitLambdaExpr(LambdaExpr *E) {
- return VisitCXXMethodDecl(E->getCallOperator());
- }
-
- // Blocks don't support default parameters, and, as for lambdas,
- // we don't consider their body a subexpression.
- bool VisitBlockDecl(BlockDecl *B) { return false; }
-
- bool VisitCompoundStmt(CompoundStmt *B) {
- return false;
- }
-
- bool VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
- return TraverseStmt(E->getExpr());
- }
-
- bool VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
- return TraverseStmt(E->getExpr());
- }
-};
-
-struct EnsureImmediateInvocationInDefaultArgs
- : TreeTransform<EnsureImmediateInvocationInDefaultArgs> {
- EnsureImmediateInvocationInDefaultArgs(Sema &SemaRef)
- : TreeTransform(SemaRef) {}
-
- // Lambda can only have immediate invocations in the default
- // args of their parameters, which is transformed upon calling the closure.
- // The body is not a subexpression, so we have nothing to do.
- // FIXME: Immediate calls in capture initializers should be transformed.
- ExprResult TransformLambdaExpr(LambdaExpr *E) { return E; }
- ExprResult TransformBlockExpr(BlockExpr *E) { return E; }
-};
-
ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
- FunctionDecl *FD, ParmVarDecl *Param,
- Expr *Init) {
+ FunctionDecl *FD, ParmVarDecl *Param) {
assert(Param->hasDefaultArg() && "can't build nonexistent default arg");
-
- bool NestedDefaultChecking =
- isCheckingDefaultArgumentOrInitializerOfOuterEntity();
-
- llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
- InitializationContext =
- OutermostDeclarationWithDelayedImmediateInvocations();
- if (!InitializationContext.has_value())
- InitializationContext.emplace(CallLoc, Param, CurContext);
-
- if (!Init && !Param->hasUnparsedDefaultArg()) {
- // Mark that we are replacing a default argument first.
- // If we are instantiating a template we won't have to
- // retransform immediate calls.
- EnterExpressionEvaluationContext EvalContext(
- *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
- ExprEvalContexts.back().DelayedDefaultInitializationContext = {
- CallLoc, Param, CurContext};
-
- if (Param->hasUninstantiatedDefaultArg()) {
- if (InstantiateDefaultArgument(CallLoc, FD, Param))
- return ExprError();
- } else {
- // CWG2631
- // An immediate invocation that is not evaluated where it appears is
- // evaluated and checked for whether it is a constant expression at the
- // point where the enclosing initializer is used in a function call.
- ImmediateCallVisitor V;
- if (!NestedDefaultChecking)
- V.TraverseDecl(Param);
- if (V.HasImmediateCalls) {
- EnsureImmediateInvocationInDefaultArgs Immediate(*this);
- ExprResult Res = Immediate.TransformExpr(Param->getInit());
- if (Res.isInvalid())
- return ExprError();
- Res = ConvertParamDefaultArgument(Param, Res.get(),
- Res.get()->getBeginLoc());
- if (Res.isInvalid())
- return ExprError();
- Init = Res.get();
- }
- }
- }
-
- if (CheckCXXDefaultArgExpr(
- CallLoc, FD, Param, Init,
- /*SkipImmediateInvocations=*/NestedDefaultChecking))
+ if (CheckCXXDefaultArgExpr(CallLoc, FD, Param))
return ExprError();
-
- return CXXDefaultArgExpr::Create(Context, InitializationContext->Loc, Param,
- Init, InitializationContext->Context);
-}
-
-ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
- assert(Field->hasInClassInitializer());
-
- // If we might have already tried and failed to instantiate, don't try again.
- if (Field->isInvalidDecl())
- return ExprError();
-
- auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
-
- llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
- InitializationContext =
- OutermostDeclarationWithDelayedImmediateInvocations();
- if (!InitializationContext.has_value())
- InitializationContext.emplace(Loc, Field, CurContext);
-
- Expr *Init = nullptr;
-
- bool NestedDefaultChecking =
- isCheckingDefaultArgumentOrInitializerOfOuterEntity();
-
- if (!Field->getInClassInitializer()) {
- // Maybe we haven't instantiated the in-class initializer. Go check the
- // pattern FieldDecl to see if it has one.
- if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
- CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
- DeclContext::lookup_result Lookup =
- ClassPattern->lookup(Field->getDeclName());
-
- FieldDecl *Pattern = nullptr;
- for (auto *L : Lookup) {
- if ((Pattern = dyn_cast<FieldDecl>(L)))
- break;
- }
- assert(Pattern && "We must have set the Pattern!");
- if (!Pattern->hasInClassInitializer() ||
- InstantiateInClassInitializer(Loc, Field, Pattern,
- getTemplateInstantiationArgs(Field))) {
- Field->setInvalidDecl();
- return ExprError();
- }
- }
- } else {
- // CWG2631
- // An immediate invocation that is not evaluated where it appears is
- // evaluated and checked for whether it is a constant expression at the
- // point where the enclosing initializer is used in a [...] a constructor
- // definition, or an aggregate initialization.
- EnterExpressionEvaluationContext EvalContext(
- *this, ExpressionEvaluationContext::PotentiallyEvaluated, Field);
- ExprEvalContexts.back().DelayedDefaultInitializationContext = {Loc, Field,
- CurContext};
-
- ImmediateCallVisitor V;
- if (!NestedDefaultChecking)
- V.TraverseDecl(Field);
- if (V.HasImmediateCalls) {
- EnsureImmediateInvocationInDefaultArgs Immediate(*this);
- ExprResult Res = Immediate.TransformExpr(Field->getInClassInitializer());
- if (!Res.isInvalid())
- Res = ConvertMemberDefaultInitExpression(Field, Res.get(), Loc);
- if (!Res.isInvalid())
- Res = MaybeCreateExprWithCleanups(Res.get());
- if (Res.isInvalid()) {
- Field->setInvalidDecl();
- return ExprError();
- }
- Init = Res.get();
- } else if (!NestedDefaultChecking) {
- MarkDeclarationsReferencedInExpr(Field->getInClassInitializer());
- }
- }
- if (Field->getInClassInitializer())
- return CXXDefaultInitExpr::Create(Context, InitializationContext->Loc,
- Field, InitializationContext->Context,
- Init);
-
- // DR1351:
- // If the brace-or-equal-initializer of a non-static data member
- // invokes a defaulted default constructor of its class or of an
- // enclosing class in a potentially evaluated subexpression, the
- // program is ill-formed.
- //
- // This resolution is unworkable: the exception specification of the
- // default constructor can be needed in an unevaluated context, in
- // particular, in the operand of a noexcept-expression, and we can be
- // unable to compute an exception specification for an enclosed class.
- //
- // Any attempt to resolve the exception specification of a defaulted default
- // constructor before the initializer is lexically complete will ultimately
- // come here at which point we can diagnose it.
- RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
- Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
- << OutermostClass << Field;
- Diag(Field->getEndLoc(),
- diag::note_default_member_initializer_not_yet_parsed);
- // Recover by marking the field invalid, unless we're in a SFINAE context.
- if (!isSFINAEContext())
- Field->setInvalidDecl();
- return ExprError();
+ return CXXDefaultArgExpr::Create(Context, CallLoc, Param, CurContext);
}
Sema::VariadicCallType
ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
if (isUnevaluatedContext() || !E.isUsable() || !Decl ||
!Decl->isConsteval() || isConstantEvaluated() ||
- isCheckingDefaultArgumentOrInitializer() ||
RebuildingImmediateInvocation || isImmediateFunctionContext())
return E;
FD = Call->getConstructor();
else
llvm_unreachable("unhandled decl kind");
- assert(FD && FD->isConsteval());
+ assert(FD->isConsteval());
SemaRef.Diag(CE->getBeginLoc(), diag::err_invalid_consteval_call) << FD;
- if (auto Context =
- SemaRef.InnermostDeclarationWithDelayedImmediateInvocations()) {
- SemaRef.Diag(Context->Loc, diag::note_invalid_consteval_initializer)
- << Context->Decl;
- SemaRef.Diag(Context->Decl->getBeginLoc(), diag::note_declared_at);
- }
for (auto &Note : Notes)
SemaRef.Diag(Note.first, Note.second);
return;
if (auto *FD = dyn_cast<FunctionDecl>(E->getDecl()))
if (!isUnevaluatedContext() && !isConstantEvaluated() &&
- !isImmediateFunctionContext() &&
- !isCheckingDefaultArgumentOrInitializer() && FD->isConsteval() &&
+ !isImmediateFunctionContext() && FD->isConsteval() &&
!RebuildingImmediateInvocation && !FD->isDependentContext())
ExprEvalContexts.back().ReferenceToConsteval.insert(E);
MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse,
assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->
getDescribedFunctionTemplate() &&
"Default arg expressions are never formed in dependent cases.");
- return SemaRef.BuildCXXDefaultArgExpr(
- E->getUsedLocation(), cast<FunctionDecl>(E->getParam()->getDeclContext()),
- E->getParam());
+ return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
+ cast<FunctionDecl>(E->getParam()->getDeclContext()),
+ E->getParam());
}
template<typename Fn>
ContextRAII SavedContext(*this, Instantiation->getParent());
EnterExpressionEvaluationContext EvalContext(
*this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
- ExprEvalContexts.back().DelayedDefaultInitializationContext = {
- PointOfInstantiation, Instantiation, CurContext};
LocalInstantiationScope Scope(*this, true);
/// By default, builds a new default-argument expression, which does not
/// require any semantic analysis. Subclasses may override this routine to
/// provide different behavior.
- ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param,
- Expr *RewrittenExpr) {
+ ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param) {
return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param,
- RewrittenExpr, getSema().CurContext);
+ getSema().CurContext);
}
/// Build a new C++11 default-initialization expression.
/// routine to provide different behavior.
ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
FieldDecl *Field) {
- return getSema().BuildCXXDefaultInitExpr(Loc, Field);
+ return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field,
+ getSema().CurContext);
}
/// Build a new C++ zero-initialization expression.
if (!Param)
return ExprError();
- ExprResult InitRes;
- if (E->hasRewrittenInit()) {
- InitRes = getDerived().TransformExpr(E->getRewrittenExpr());
- if (InitRes.isInvalid())
- return ExprError();
- }
-
if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
- E->getUsedContext() == SemaRef.CurContext &&
- InitRes.get() == E->getRewrittenExpr())
+ E->getUsedContext() == SemaRef.CurContext)
return E;
- return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param,
- InitRes.get());
+ return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
}
template<typename Derived>
E->Param = readDeclAs<ParmVarDecl>();
E->UsedContext = readDeclAs<DeclContext>();
E->CXXDefaultArgExprBits.Loc = readSourceLocation();
- E->CXXDefaultArgExprBits.HasRewrittenInit = Record.readInt();
- if (E->CXXDefaultArgExprBits.HasRewrittenInit)
- *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
}
void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
E->Field = readDeclAs<FieldDecl>();
E->UsedContext = readDeclAs<DeclContext>();
E->CXXDefaultInitExprBits.Loc = readSourceLocation();
- E->CXXDefaultInitExprBits.HasRewrittenInit = Record.readInt();
- if (E->CXXDefaultInitExprBits.HasRewrittenInit)
- *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
}
void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
break;
case EXPR_CXX_DEFAULT_ARG:
- S = CXXDefaultArgExpr::CreateEmpty(
- Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
+ S = new (Context) CXXDefaultArgExpr(Empty);
break;
case EXPR_CXX_DEFAULT_INIT:
- S = CXXDefaultInitExpr::CreateEmpty(
- Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
+ S = new (Context) CXXDefaultInitExpr(Empty);
break;
case EXPR_CXX_BIND_TEMPORARY:
Record.AddDeclRef(E->getParam());
Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
Record.AddSourceLocation(E->getUsedLocation());
- Record.push_back(E->hasRewrittenInit());
- if (E->hasRewrittenInit())
- Record.AddStmt(E->getRewrittenExpr());
Code = serialization::EXPR_CXX_DEFAULT_ARG;
}
Record.AddDeclRef(E->getField());
Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
Record.AddSourceLocation(E->getExprLoc());
- Record.push_back(E->hasRewrittenInit());
- if (E->hasRewrittenInit())
- Record.AddStmt(E->getRewrittenExpr());
Code = serialization::EXPR_CXX_DEFAULT_INIT;
}
int x = 3; // expected-note{{'x' declared here}}
struct C {
int& x2 = x; // expected-error{{reference to local variable 'x' declared in enclosing lambda expression}}
- }c; // expected-note {{required here}}
+ };
};
- C(); // expected-note {{required here}}
+ C();
}
// RUN: %clang_cc1 -no-opaque-pointers -std=c++2a -fblocks %s -triple x86_64-unknown-unknown -emit-llvm -o %t.ll
-// RUN: %clang_cc1 -no-opaque-pointers -std=c++14 -fblocks %s -triple x86_64-unknown-unknown -emit-llvm -o %t.ll
-
// This needs to be performed before #line directives which alter filename
// RUN: %clang_cc1 -no-opaque-pointers -fno-file-reproducible -fmacro-prefix-map=%p=/UNLIKELY/PATH -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-PREFIX-MAP
+++ /dev/null
-// RUN: %clang_cc1 -std=c++2a -triple x86_64-elf-gnu %s -emit-llvm -o - | FileCheck %s
-
-consteval int immediate() { return 0;}
-static int ext();
-void f(int a = immediate() + ext());
-
-void test_function() {
- f();
- f(0);
- // CHECK: call noundef i32 @_ZL3extv()
- // CHECK: add
- // CHECK: call {{.*}} @_Z1fi
- // CHECK: call {{.*}} @_Z1fi
-}
-
-// CHECK: define {{.*}} i32 @_ZL3extv()
-
-static constexpr int not_immediate();
-struct A {
- int a = immediate() + not_immediate();
-};
-
-void test_member() {
- // CHECK: call void @_ZN1AC2Ev
- A defaulted;
- // CHECK-NOT: call void @_ZN1AC2Ev
- A provided{0};
-}
-
-// CHECK: define {{.*}} void @_ZN1AC2Ev{{.*}}
-// CHECK: %call = call noundef i32 @_ZL13not_immediatev()
-
-int never_referenced() {return 42;};
-
-
-namespace not_used {
-
-struct A {
- int a = immediate() + never_referenced();
-};
-void f(int a = immediate() + never_referenced());
-
-void g() {
- A a{0};
- f(0);
-}
-
-}
-
-static int ext() {return 0;}
-static constexpr int not_immediate() {return 0;}
-
-// CHECK-NOT: define {{.*}} i32 _ZL16never_referencedv()(
-// CHECK: define {{.*}} i32 @_ZL13not_immediatev()
+++ /dev/null
-// RUN: %clang_cc1 -std=c++20 -emit-pch %s -o %t
-// RUN: %clang_cc1 -std=c++20 -include-pch %t -verify %s
-// expected-no-diagnostics
-
-#ifndef HEADER_INCLUDED
-#define HEADER_INCLUDED
-
-consteval int immediate();
-int regular_function() {
- return 0;
-}
-
-struct S {
- int a = immediate() + regular_function();
-};
-
-int f(int arg = immediate()) {
- return arg;
-}
-
-#else
-
-consteval int immediate() {
- return 0;
-}
-
-void test() {
- f(0);
- f();
- S s{0};
- S t{0};
-}
-
-#endif
+++ /dev/null
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2b %s
-
-consteval int undefined(); // expected-note 4 {{declared here}}
-
-void check_lambdas_unused(
- int a = []
- {
- // The body of a lambda is not a subexpression of the lambda
- // so this is immediately evaluated even if the parameter
- // is never used.
- return undefined(); // expected-error {{not a constant expression}} \
- // expected-note {{undefined function 'undefined'}}
- }(),
- int b = [](int no_error = undefined()) {
- return no_error;
- }(0),
- int c = [](int defaulted = undefined()) {
- return defaulted;
- }()
-) {}
-
-int check_lambdas_used(
- int b = [](int no_error = undefined()) {
- return no_error;
- }(0),
- int c = [](int defaulted = undefined()) { // expected-error {{not a constant expression}} \
- // expected-note {{declared here}} \
- // expected-note {{undefined function 'undefined'}}
- return defaulted;
- }(), // expected-note {{in the default initalizer of 'defaulted'}}
- int d = [](int defaulted = sizeof(undefined())) {
- return defaulted;
- }()
-) {
- return 0;
-}
-
-int test_check_lambdas_used = check_lambdas_used();
-
-struct UnusedInitWithLambda {
- int a = [] {
- return undefined(); // expected-error {{not a constant expression}} \
- // expected-note {{undefined function 'undefined'}}
- }();
- // UnusedInitWithLambda is never constructed, so the initializer
- // of b and undefined() are never evaluated.
- int b = [](int no_error = undefined()) {
- return no_error;
- }();
-};
-
-consteval int ub(int n) {
- return 0/n; // expected-note {{division}}
-}
-
-struct InitWithLambda {
- int b = [](int error = undefined()) { // expected-error {{not a constant expression}} \
- // expected-note {{declared here}} \
- // expected-note {{undefined function 'undefined'}}
- return error;
- }(); // expected-note {{in the default initalizer of 'error'}}
- int c = [](int error = sizeof(undefined()) + ub(0)) { // expected-error {{'ub' is not a constant expression}} \
- // expected-note {{declared here}} \
- // expected-note {{in call to 'ub(0)}}
- return error;
- }(); // expected-note {{in the default initalizer of 'error'}}
-} i; // expected-note {{in implicit default constructor}}
// RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fexceptions -verify %s
-// RUN: %clang_cc1 -std=c++2a -fcxx-exceptions -DUSE_CONSTEVAL -fexceptions -verify %s
// expected-no-diagnostics
#define assert(...) ((__VA_ARGS__) ? ((void)0) : throw 42)
template <unsigned>
struct Printer;
-#ifdef USE_CONSTEVAL
-#define SOURCE_LOC_EVAL_KIND consteval
-#else
-#define SOURCE_LOC_EVAL_KIND constexpr
-#endif
-
namespace std {
class source_location {
struct __impl;
public:
- static SOURCE_LOC_EVAL_KIND source_location
- current(const __impl *__p = __builtin_source_location()) noexcept {
- source_location __loc;
- __loc.__m_impl = __p;
- return __loc;
+ static constexpr source_location current(const __impl *__p = __builtin_source_location()) noexcept {
+ source_location __loc;
+ __loc.__m_impl = __p;
+ return __loc;
}
constexpr source_location() = default;
constexpr source_location(source_location const &) = default;
}
static_assert(test());
}
-
-namespace Lambda {
-#line 8000 "TestLambda.cpp"
-constexpr int nested_lambda(int l = []{
- return SL::current().line();
-}()) {
- return l;
-}
-static_assert(nested_lambda() == __LINE__ - 4);
-
-constexpr int lambda_param(int l = [](int l = SL::current().line()) {
- return l;
-}()) {
- return l;
-}
-static_assert(lambda_param() == __LINE__);
-
-
-}
-
-constexpr int compound_literal_fun(int a =
- (int){ SL::current().line() }
-) { return a ;}
-static_assert(compound_literal_fun() == __LINE__);
-
-struct CompoundLiteral {
- int a = (int){ SL::current().line() };
-};
-static_assert(CompoundLiteral{}.a == __LINE__);
-
-
-// FIXME
-// Init captures are subexpressions of the lambda expression
-// so according to the standard immediate invocations in init captures
-// should be evaluated at the call site.
-// However Clang does not yet implement this as it would introduce
-// a fair bit of complexity.
-// We intend to implement that functionality once we find real world
-// use cases that require it.
-constexpr int test_init_capture(int a =
- [b = SL::current().line()] { return b; }()) {
- return a;
-}
-#ifdef USE_CONSTEVAL
-static_assert(test_init_capture() == __LINE__ - 4);
-#else
-static_assert(test_init_capture() == __LINE__ );
-#endif
projects / platform / upstream / llvm.git / commitdiff