Compiler Explorer

Source code

#include <algorithm>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <type_traits>

namespace detail {
  // Helper utilities for preserving cv qualifiers.
  template<typename To, typename From>
  using copy_const_t = std::conditional_t<std::is_const_v<From>, std::add_const_t<To>, To>;
  template<typename To, typename From>
  using copy_volatile_t = std::conditional_t<std::is_volatile_v<From>, std::add_volatile_t<To>, To>;
  template<typename To, typename From>
  using copy_cv_t = copy_volatile_t<copy_const_t<To, From>, From>;

// Underlying type suport extended to character types.
  template<typename T>
  struct underlying_type_ex : std::underlying_type_t<T> {};
  template<typename T>
  struct underlying_type_ex<const T> : underlying_type_ex<T> {};
  template<typename T>
  struct underlying_type_ex<volatile T> : underlying_type_ex<T> {};
  template<typename T>
  struct underlying_type_ex<const volatile T> : underlying_type_ex<T> {};
  template<>
  struct underlying_type_ex<char> {
    // This is arguably incorrect when char is signed.
    using type = unsigned char;
  };
  template<>
  struct underlying_type_ex<unsigned char> {
    using type = unsigned char;
  };
  template<>
  struct underlying_type_ex<wchar_t> {
    // This is arguably incorrect when wchar_t is signed.
    // And definitely incorrect when sizeof(wchar_t) is neither 2 nor 4!
    using type = std::conditional_t<sizeof(wchar_t) == 2, std::uint_least16_t, std::uint_least32_t>;
  };
  template<>
  struct underlying_type_ex<char8_t> {
    using type = unsigned char;
  };
  template<>
  struct underlying_type_ex<char16_t> {
    using type = std::uint_least16_t;
  };
  template<>
  struct underlying_type_ex<char32_t> {
    using type = std::uint_least32_t;
  };
  template<typename T>
  using underlying_type_ex_t = typename underlying_type_ex<T>::type;
}

template<typename T, typename E>
requires std::same_as<detail::underlying_type_ex_t<T>, detail::underlying_type_ex_t<E>>
struct underlying_type_access_handle {
  E* original_ptr;
  T* borrowed_ptr;
  std::size_t n;
};

// underlying_type_access. Given a contiguous range specified with a pointer
// and size, invoke compiler magic to enable the n object(s) of type E at
// location p to be accessed using a type T that has the same underlying type
// as E. This operation is similar to reinterpret_cast but can be performed
// during constant evaluation.
//
// Upon return, the objects reachable from p may only be accessed using type T
// (or a type similar to T, or the aliasing types char, unsigned char, and
// std::byte); access using type E becomes UB (due to allowances for TBAA-based
// optimization). Upon invocation, implementations that perform TBAA are
// required to behave as though this function performs a read of an object of
// type E of unknown provinence (thereby ensuring that any writes to objects of
// type E have been completed).
template<typename T, typename E>
requires std::same_as<detail::underlying_type_ex_t<T>, detail::underlying_type_ex_t<E>>
constexpr auto acquire_underlying_type_access(E *p, std::size_t n = 1) {
  using X = detail::copy_cv_t<T, E>;
  underlying_type_access_handle<X, E> utah{ p, nullptr, n };
  auto x = new std::remove_const_t<X>[n];
  std::copy(p, p+n, x);
  utah.borrowed_ptr = x;
  return utah;
}

// Upon return, the objects reachable from p may only be accessed using type T
// (or a type similar to T, or the aliasing types char, unsigned char, and
// std::byte); access using type E becomes UB (due to allowances for TBAA-based
// optimization). Upon invocation, implementations that perform TBAA are
// required to behave as though this function performs a read of an object of
// type T of unknown provinence (thereby ensuring that any writes to objects of
// type E have been completed) followed by a write of an object of type E of
// unknown provinence (thereby ensuring that future reads of objects reachable
// from p will result in a load).
template<typename T, typename E>
constexpr void release_underlying_type_access(underlying_type_access_handle<T, E> &utah) {
  if constexpr (not std::is_const_v<E>)
    std::copy(utah.borrowed_ptr, utah.borrowed_ptr+utah.n, utah.original_ptr);
  delete[] utah.borrowed_ptr;
}

Source code

#include "underlying_type_access"
#include <array>
#include <concepts>
#include <cstddef>
#include <ranges>
#include <span>
#include <type_traits>

namespace detail {
  // Helper utilities for CTAD type deduction.
  template<typename>
  struct type_t {};
  template<typename T>
  inline type_t<T> type_v;

template<typename>
  inline constexpr auto get_extent = std::dynamic_extent;
  template<typename T>
  inline constexpr auto get_extent<const T> = get_extent<T>;
  template<typename T>
  inline constexpr auto get_extent<volatile T> = get_extent<T>;
  template<typename T>
  inline constexpr auto get_extent<const volatile T> = get_extent<T>;
  template<typename T>
  inline constexpr auto get_extent<T&> = get_extent<T>;
  template<typename T>
  inline constexpr auto get_extent<T&&> = get_extent<T>;
  template<typename T, std::size_t N>
  inline constexpr auto get_extent<T[N]> = N;
  template<typename T, std::size_t N>
  inline constexpr auto get_extent<std::span<T, N>> = N;
  template<typename T, std::size_t N>
  inline constexpr auto get_extent<std::array<T, N>> = N;
}

// borrowed_object_view. On construction, underlying_type_access() is
// invoked to produce a view 
template<typename T, typename R>
requires std::ranges::contiguous_range<R>
      && std::ranges::sized_range<R>
      && std::ranges::view<R>      
class borrowed_object_view {
  using original_element_type = std::remove_reference_t<decltype(*std::ranges::begin(std::declval<R>()))>;
  using borrowed_element_type = detail::copy_cv_t<T, original_element_type>;
  using borrowed_view_type = std::span<borrowed_element_type, detail::get_extent<R>>;

public:
  borrowed_object_view(const borrowed_object_view&) = delete;
  borrowed_object_view(borrowed_object_view&&) = delete;
  borrowed_object_view& operator=(const borrowed_object_view&) = delete;
  borrowed_object_view& operator=(borrowed_object_view&&) = delete;

// Constructor. 
  constexpr borrowed_object_view(R r)
    : utah(acquire_underlying_type_access<borrowed_element_type>(
               &*std::ranges::begin(r),
               std::ranges::size(r)))
  {}
  // Helper constructor to guide type deduction for CTAD.
  constexpr borrowed_object_view(detail::type_t<T>, R r)
    : borrowed_object_view(r)
  {}

constexpr ~borrowed_object_view() {
    release_underlying_type_access(utah);
  }

// More transparency could be achieved if it was possible to have
  // a conversion operator that returned a reference to an array
  // (with a static extent if known statically and unbounded otherwise).
  // Conversion to a view with (possibly static) extent.
  constexpr operator borrowed_view_type() const {
    return borrowed_view_type{utah.borrowed_ptr, utah.n};
  }
  // Simulate decay to pointer.
  constexpr operator borrowed_element_type*() const {
    return utah.borrowed_ptr;
  }

private:
  underlying_type_access_handle<borrowed_element_type, original_element_type> utah;
};

// CTAD helper to use std::span for a non-view source range.
template<typename T, typename R>
requires std::ranges::contiguous_range<R>
      && std::ranges::sized_range<R>
      && std::ranges::borrowed_range<R>
      && (not std::ranges::view<R>)
borrowed_object_view(detail::type_t<T>, R&& r) -> borrowed_object_view<T, decltype(std::span(r))>;

template<typename T, typename R>
requires std::ranges::contiguous_range<R>
      && std::ranges::sized_range<R>
      && std::ranges::borrowed_range<R>
constexpr auto borrow_as(R &&r) {
  return borrowed_object_view(detail::type_v<T>, r);
}

template<typename T, typename E>
constexpr auto borrow_as(E *p, std::size_t n) {
  return borrowed_object_view(detail::type_v<T>, std::span(p, p+n));
}

Source code

#include "borrow"
#include <cassert>
#include <string>
#include <string_view>
#include <vector>

constexpr char read_char_as_utf8(const char *p) {
  return p[0];
}
constexpr unsigned char read_unsigned_char_as_utf8(const unsigned char *p) {
  return p[0];
}

constexpr char write_char_as_utf8(char *p) {
  return p[0] = '2';
}
constexpr unsigned char write_unsigned_char_as_utf8(unsigned char *p) {
  return p[0] = '3';
}

template<std::ranges::contiguous_range R>
constexpr char read_char8_test(R &&r) {
  auto x = read_char_as_utf8(borrow_as<char>(r)); // Ok, x == 't'.
  auto y = read_unsigned_char_as_utf8(borrow_as<unsigned char>(r)); // Ok, y == 't'.
  (void)r[0]; // Ok, value == 't'.
  {
    const auto &bc = borrow_as<char>(r);
    const char *cp = bc;
    (void)cp[0];  // Ok.
    (void)r[0]; // UB: An object of type char is now there.
  }
  return r[0]; // Ok, returns 't'.
}

template<std::ranges::contiguous_range R>
constexpr char8_t write_char8_test(R &&r) {
  read_char8_test(r);
  r[0] = '1';
  auto x = write_char_as_utf8(borrow_as<char>(r)); // Ok, x == '1'.
  auto y = write_unsigned_char_as_utf8(borrow_as<unsigned char>(r)); // Ok, y == '1'.
  (void)r[0]; // Ok, value == '1'.
  {
    const auto &bc = borrow_as<char>(r);
    char *cp = bc;
    cp[0] = 'X';  // Ok.
    (void)r[0]; // UB: An object of type char is now there.
  }
  return r[0]; // Ok, returns 'X'.
}
constinit auto constexpr_test = [] {
  static_assert([] {
                  char8_t c8a[] = u8"text";
                  return write_char8_test(c8a);
                }() == 'X');
  static_assert(write_char8_test(std::u8string(u8"text")) == 'X');
  static_assert([] {
                  std::u8string u8s(u8"text");
                  return read_char8_test(std::u8string_view(u8s));
                }() == 't');
  static_assert(write_char8_test(std::vector{u8't', u8'e', u8'x', u8't'}) == 'X');
  static_assert(write_char8_test(std::array{u8't', u8'e', u8'x', u8't'}) == 'X');
  static_assert([] {
                  std::array a{u8't', u8'e', u8'x', u8't'};
                  return write_char8_test(std::span(a));
                }() == 'X');
  return 0;
}();

int main() {
  assert(([] {
            char8_t c8a[] = u8"text";
            return write_char8_test(c8a);
          }() == 'X'));
  assert(write_char8_test(std::u8string(u8"text")) == 'X');
  assert(write_char8_test(std::vector{u8't', u8'e', u8'x', u8't', u8'\0'}) == 'X');
  assert(write_char8_test(std::array{u8't', u8'e', u8'x', u8't', u8'\0'}) == 'X');
  assert(([] {
            std::array a{u8't', u8'e', u8'x', u8't'};
            return write_char8_test(std::span(a));
          }() == 'X'));
}