Issue 4138: is_within_lifetime should mandate is_object

Title: is_within_lifetime should mandate is_object
Status: new
Section: [meta.const.eval]
Submitter: Corentin

Created on 2024-08-09.00:00:00 last changed yesterday

Messages

msg16399 (view)

Date: 2026-06-10.06:38:36

Proposed resolution:

This wording is relative to N5046.

Modify [meta.const.eval] as indicated:
```
template<class U = void, class T>
  consteval bool is_within_lifetime(const T* p) noexcept;
```
-3- Mandates: static_cast<const volatile U*>(p) is well-formed. `T` is an object type or cv `void`.
-4- Returns: true if p is a pointer to an object that is within its lifetime ([basic.life]) and static_cast<const volatile U*>(p) is a constant subexpression; otherwise, false.
-4- Remarks: During the evaluation of an expression E as a core constant expression, a call to this function is ill-formed unless p points to an object that is usable in constant expressions or whose complete object's lifetime began within E.

msg15166 (view)

Date: 2026-06-15.00:00:00

[ 2026-06-09; Tim rebases and provides new wording ]

Functions do not have lifetimes as far as the standard is concerned. However, there is no reason to ban `void`.

msg14322 (view)

Date: 2025-10-15.00:00:00

[ 2025-10-14; Reflector poll ]

Set priority to 3 after reflector poll.

"What about `void*`, should that be allowed? The compiler should know which union member the `void*` came from, as this is only using during constant evaluation."

"NAD, a function could have its lifetime constrained by a dynamic loader, so it seems wrong to assume that taling of function lifetimes makes no sense."

This wording is relative to N4988.

Modify [meta.type.synop], header <type_traits> synopsis, as indicated:

[…]
// [meta.const.eval], constant evaluation context
constexpr bool is_constant_evaluated() noexcept;
template<class T>
consteval bool is_within_lifetime(const Tauto*) noexcept;

Modify [meta.const.eval] as indicated:
```
template<class T>
consteval bool is_within_lifetime(const Tauto* p) noexcept;
```
-?- Mandates: is_object_v<T> is true.
-3- Returns: true if p is a pointer to an object that is within its lifetime ([basic.life]); otherwise, false.
-4- Remarks: During the evaluation of an expression E as a core constant expression, a call to this function is ill-formed unless p points to an object that is usable in constant expressions or whose complete object's lifetime began within E.

msg14321 (view)

Date: 2024-08-09.00:00:00

int f();
std::is_within_lifetime<int()>(f);

This is currently well-formed, and only fails when evaluated because is_within_lifetime is not constrained. However talking of lifetime of a non-object does not make sense, and the lack of constraint makes the implementation and use of that function and underlying built-in more convoluted than necessary.

History
Date	User	Action	Args
2026-06-10 06:38:36	admin	set	messages: + msg16399
2025-10-14 21:30:14	admin	set	messages: + msg15166
2024-08-11 11:03:50	admin	set	messages: + msg14322
2024-08-09 00:00:00	admin	create