P4147R0: constexpr => runtime bridge

Value check

As this magic_function() is called when constant evaluation is left, there is no context around, but it is still part of the constant evaluation (if the function overload is consteval) throwing an exception here can be used as a custom error message for when a type is moved from constant evaluation.

class mutex {
	// ...
	consteval mutex & magic_function() const {
		if (this->__is_locked()) {
			throw __custom_error_message{"leaking locked mutex"};
		}
		return *this;
	}
}

auto && magic_function(auto && obj) {
	if constexpr (is_pointer_type(^^obj)) {
		if (__is_heap_allocated(obj)) {
			throw not_released_memory(__allocation_source_location(obj));
		}
	} else if (is_lvalue_reference_type(^^obj)) {
		if (__is_heap_allocated(&obj)) {
			throw not_released_memory(__allocation_source_location(&obj));
		}
	}
	
	// TODO: fix infinite loop in self-referencing objects
	template for (constexpr auto member: nonstatic_data_members_of(^^obj, std::meta::access_context::unchecked()) {
		// TODO: apologize to reflection folks for probably buggy example
		if constexpr (is_pointer_type(member)) {
			if (obj.[:member:] != nullptr) {
				magic_function(*obj.[:member:]);
			}
		} else if constexpr (is_lvalue_reference_type(member)) {
			magic_function(obj.[:member:]);
		}
	}
	
	return obj;
}

Value transformation

In following example transformation returns new string pointing at a static storage, instead to a heap allocation.

class string {
	// ...
	constexpr const char * data() const;
	constexpr size_t size() const;
	constexpr const_iterator begin() const;
	constexpr const_iterator end() const;
	
	consteval string magic_function() const {
		return {std::meta::define_static_string(*this), this->size()};
	}
	
	constexpr ~string() {
		if (!__is_static_storage(this->data())) { // assume we have such magical function
			delete[] this->data();
		}
	}
};

Transformations to get constexpr non-transient allocations

In following example instead of just returning same type, it changes the template argument of itself and changes its allocator, which simply won't deallocate the memory.

template <typename CharT, typename Traits, typename Alloc> class basic_string {
	// ...
	consteval auto magic_function() const {
		return basic_string<CharT, Traits, static_storage_alloc>{std::meta::define_static_string(*this), this->size()};
	}
}

Alternative transformations

If we can change type, we can go farther.

template <typename T> class vector {
	// ...
	consteval auto magic_function() const {
		return define_static_array(...);
	}
}

Alternative transformations

Perhaps most extreme example is a combination with constexpr coroutines, this would allow us to start a coroutine, which is immediately suspended and transfer it into runtime world, but elliding allocations. This would make such code very usable for making state machines in safety oriented industry where allocations are simply not allowed.

constexpr lazy_coro my_state_coroutine(); 

struct lazy_coro {
	struct promise_type {
		consteval auto initial_suspend() { return std::suspend_always{}; }
		consteval auto & magic_function() const {
			// create a static byte storage with similar function as define_static_object
			// copy current object into (currently impossible, but I'm exploring this)
			return // reference to the copy
		}
	};
};

static constint auto dsm = my_state_coroutine();

Of course this is highly hypothetical, but it's an interesting idea.

constexpr variable

constexpr auto a =                constant_calculation();  // before
constexpr auto b = magic_function(constant_calculation()); // after (implicitly)

constinit static variable

static constinit auto a =                constant_calculation();  // before
static constinit auto b = magic_function(constant_calculation()); // after (implicitly)

consteval evaluation

consteval auto constant_calculation() { ... }
	
auto function() { // notice it's not constexpr nor consteval
	auto a =                constant_calculation();  // before
	auto b = magic_function(constant_calculation()); // after (implicitly)
}

Argument against a free function in std:: namespace

I we decide to have this function reside in std:: namespace it would be a not friend customization point, user would need to close their namespace and then provide overload or even worse specialization in std:: namespace.

Name of it

I don't partically care, but it if we are going to do a free function it shouldn't be something which already exists, maybe operator constexpr (as constexpr is combination of runtime and constant evaluation) which will give us funnily following syntax:

struct a_type {
	consteval auto operator constexpr() const {
		// hey it's me, `static` :)
	}
}

Why the function should be consteval?

It doesn't need to, this makes sure the transformation happen during compile time. If the function is not marked constexpr nor consteval then you can't trigger compilation failure with constexpr exceptions. But I can imagine scenarios where there is something to be done in runtime after object is prepared in constant time, perhaps seeding a cryptography operation.

When exactly it is called?

There is multiple following options:

• whenever constant evaluation is yielding a value (immediately),
• when the value is ODR used outside constant evaluation (when used).

Both has upside and downside. Major upside for the first option the implementation is easier, whenever a constexpr or constinit variable is initialized, or in root of the any constant evaluated expression which result is accessible from runtime (not static_assert, but yes for template arguments).

Upside of second option is that it happens only when the value will be really visible in the runtime code. But that can also be on multiple places.

constexpr Foo cnstxprvl = constant_calculation();  // no transformation here

consteval Foo magic_function(Foo & f) { ... }

// BEFORE author doesn't know it's going to be moved to runtime world
// AFTER transformation called as consteval code
if (magic_function(cnstxprvl)) { ...}

// and again
if (magic_function(cnstxprvl)) { ...}