Clang fails to compile correct program with consteval

[socketpair]

https://godbolt.org/z/3o1G81ahn

#include <array>
#include <iostream>
#include <ranges>
#include <string>

using namespace std;

template <size_t N>
consteval auto make_static(const string& str) {
    array<char, N> arr;
    str.copy(arr.data(), arr.size());
    return arr;
}

consteval string foo() { return string("some dynamic data") + " 42\n"; }

int main() {

// WORKS:
//    constexpr auto xxx = make_static<foo().size()>(foo());
//    cout << (xxx | ranges::to<string>());

   cout << (make_static<foo().size()>(foo()) | ranges::to<string>());

    return 0;
}

Clang fails to compile correct (I think yes :) program. GCC works. UB ?

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Коренберг Марк (socketpair)

https://godbolt.org/z/3o1G81ahn

#include <array>
#include <iostream>
#include <ranges>
#include <string>

using namespace std;

template <size_t N>
consteval auto make_static(const string& str) {
    array<char, N> arr;
    str.copy(arr.data(), arr.size());
    return arr;
}

consteval string foo() { return string("some dynamic data") + " 42\n"; }

int main() {

// WORKS:
//    constexpr auto xxx = make_static<foo().size()>(foo());
//    cout << (xxx | ranges::to<string>());

   cout << (make_static<foo().size()>(foo()) | ranges::to<string>());

    return 0;
}

Clang fails to compile correct (I think yes :) program. GCC works. UB ?

[cor3ntin]

Note that this compiles with libc++ - we need a reduction to figure out what libstdc++ is doing

[keinflue]

Happens with libc++ as well if the string is a bit longer.

Reduction:

struct A {
    char* x = new char[1];
    constexpr ~A() { delete[] x; }
};

consteval void f(const A& str) {}

consteval A g() { return A(); }

int main() {
    f(g());
}

I think this should be well-formed after P2564R3 per [expr.const]/15.2, because the call to f is an immediate invocation and therefore g() is subexpression of a manifestly constant-evaluated expression, putting it in an immediate function context where the call g() itself need not be a constant expression.

[Endilll]

I reduced the original example with the help of C-Reduce (https://godbolt.org/z/qv5TGWcj8):

namespace std {

template < typename >
struct allocator {
  constexpr char *allocate() {
    return static_cast< char * >(operator new(0));
  }
};

struct __cxx11_basic_string {
  struct _Alloc_hider {
    char* _M_p;
  } _M_dataplus;
  
  constexpr __cxx11_basic_string() : _M_dataplus() {
    allocator< char > __a;
    _M_dataplus._M_p = __a.allocate();
  }
};

} // namespace std

consteval std::__cxx11_basic_string foo() {
  return {};
}

int main() {
  (void)foo();
}

Clang 20.0 output:

<source>:28:9: error: call to consteval function 'foo' is not a constant expression
   28 |   (void)foo();
      |         ^
<source>:28:9: note: pointer to subobject of heap-allocated object is not a constant expression
<source>:6:34: note: heap allocation performed here
    6 |     return static_cast< char * >(operator new(0));
      |                                  ^
1 error generated.

One can go further and inline the allocator, but it changes the diagnostics, so decided to stop there.

[socketpair]

@Endilll so is my example correct? i.e., what I really need is for clang to create some byte array (string) based on constants at compile time. I'm not sure if std::string can be used for this purpose according to standards and requirements. If it works sometimes — then there is something like UB — i.e., it may or may not work. What solution is guaranteed to work? On one hand, expressions with new cannot be consteval, but on the other hand, they work.

[MitalAshok]

@Endilll I don't think that's quite right because calling that function will never be a constant expression by itself because the destructor isn't called in the immediate-invocation. Something more like this would be closer: https://godbolt.org/z/Eaz918nTq

Which I think can be reduced to: https://godbolt.org/z/obzMses48

struct minimal_unique_ptr {
  int* p;
  constexpr minimal_unique_ptr(int* p) : p(p) {}
  minimal_unique_ptr(minimal_unique_ptr&&) = delete;
  constexpr ~minimal_unique_ptr() { delete p; }
};

consteval minimal_unique_ptr f(int i) {
  return minimal_unique_ptr(new int(i));
}

consteval void g(minimal_unique_ptr) {}
consteval void h(minimal_unique_ptr const&) {}

int main() {
  g(f(0)); // no error on both gcc and clang
  h(f(0)); // error on clang only
  h(minimal_unique_ptr(new int(0))); // no error on both gcc and clang
  // (last one is an error with clang if constructor is made consteval)
}

It seems like Clang doesn't consider binding to a temporary to be a subexpression of the immediate invocation h(...), which doesn't look right.

Edit: more minimised: https://godbolt.org/z/sTbf6sfoY

consteval int* alloc() { return new int(0); }
consteval void f(int* p) { delete p; }
consteval void g1(int*&& p) { delete p; }
consteval void g2(const int* p) { delete p; }
consteval void g3(int*const& p) { delete p; }
struct X {
  int* p;
  explicit(false) constexpr X(int* p) : p(p) {}
};
consteval void g4(X x) { delete x.p; }

int main() {
  f(alloc());
  g1(alloc());
  g2(alloc()); // fails with clang
  g3(alloc()); // fails with clang
  g4(alloc()); // fails with clang
}