P2590R2 Explicit Lifetime Management #275

#include <cassert>
#include <concepts>
#include <memory>
#include <type_traits>
using namespace std;

template <class T>
T* StartLifetimeAs(void* const ptr) noexcept {
    static_assert(is_implicit_lifetime_v<T>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
    return __builtin_start_lifetime_as<T>(ptr);
}
template <class T>
const T* StartLifetimeAs(const void* const ptr) noexcept {
    static_assert(is_implicit_lifetime_v<T>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
    return __builtin_start_lifetime_as<T>(ptr);
}
template <class T>
volatile T* StartLifetimeAs(volatile void* const ptr) noexcept {
    static_assert(is_implicit_lifetime_v<T>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
    return __builtin_start_lifetime_as<T>(ptr);
}
template <class T>
const volatile T* StartLifetimeAs(const volatile void* const ptr) noexcept {
    static_assert(is_implicit_lifetime_v<T>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
    return __builtin_start_lifetime_as<T>(ptr);
}
template <class T>
T* StartLifetimeAsArray(void* const ptr, const size_t n) noexcept {
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
    return __builtin_start_lifetime_as_array<T>(ptr, n);
}
template <class T>
const T* StartLifetimeAsArray(const void* const ptr, const size_t n) noexcept {
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
    return __builtin_start_lifetime_as_array<T>(ptr, n);
}
template <class T>
volatile T* StartLifetimeAsArray(volatile void* const ptr, const size_t n) noexcept {
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
    return __builtin_start_lifetime_as_array<T>(ptr, n);
}
template <class T>
const volatile T* StartLifetimeAsArray(const volatile void* const ptr, const size_t n) noexcept {
    static_assert(sizeof(T) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
    return __builtin_start_lifetime_as_array<T>(ptr, n);
}
struct Point {
    int x;
    int y;
};
static_assert(alignof(Point) == alignof(int));
static_assert(sizeof(Point) == 2 * sizeof(int));

template <class CvVoidPtr, class CvPointPtr>
void test_scalar() {
    int arr[2]{17, 29};

    const auto cv_void_ptr = static_cast<CvVoidPtr>(arr);

    static_assert(noexcept(StartLifetimeAs<Point>(cv_void_ptr)));
    const same_as<CvPointPtr> auto cv_point_ptr = StartLifetimeAs<Point>(cv_void_ptr);

    assert(cv_point_ptr->x == 17);
    assert(cv_point_ptr->y == 29);
}

template <class CvVoidPtr, class CvPointPtr>
void test_array() {
    {
        // N5032 [obj.lifetime]/6: "Preconditions: p is suitably aligned for an array of T or is null."
        // N5032 [obj.lifetime]/7: "Effects: If n > 0 is true, [...]. Otherwise, there are no effects."
        const same_as<CvPointPtr> auto nil = StartLifetimeAsArray<Point>(static_cast<CvVoidPtr>(nullptr), 0);
        assert(nil == nullptr); // N5032 [obj.lifetime]/8: "otherwise, a pointer that compares equal to p"
    }

    int arr[4]{17, 29, 123, 456};

    const auto cv_void_ptr = static_cast<CvVoidPtr>(arr);

    static_assert(noexcept(StartLifetimeAsArray<Point>(cv_void_ptr, 2)));
    const same_as<CvPointPtr> auto cv_point_ptr = StartLifetimeAsArray<Point>(cv_void_ptr, 2);

    assert(cv_point_ptr[0].x == 17);
    assert(cv_point_ptr[0].y == 29);
    assert(cv_point_ptr[1].x == 123);
    assert(cv_point_ptr[1].y == 456);
}

template <class CvVoidPtr, class CvPointPtr>
void test() {
    test_scalar<CvVoidPtr, CvPointPtr>();
    test_array<CvVoidPtr, CvPointPtr>();
}

int main() {
    test<void*, Point*>();
    test<const void*, const Point*>();
    test<volatile void*, volatile Point*>();
    test<const volatile void*, const volatile Point*>();
}