On Mon, 9 Mar 2026 at 10:01, Jonathan Wakely <[email protected]> wrote: >> On 3/8/26 7:01 AM, Jonathan Wakely wrote: >> > On Sat, 7 Mar 2026, 12:38 Nathan Myers, <[email protected] >> > + * @return Memory of suitable size and alignment for @a n or >> > more >> > + * contiguous objects of type @c value_type . >> > >> > >> > Please use markdown for new doxygen comments instead of doxygen's @c or >> > html like <tt>. In general only back ticks are needed, and they're more >> > readable then the alternatives. >> Good. >> >> > + * >> > + * Returns <tt> a.allocate_at_least(n) </tt> if that expression >> > + * is well-formed, else <tt> { a.allocate(n), n } </tt>. When >> > an >> > + * allocator is obliged to reserve more space than required for >> > + * the cited @c n objects, it may deliver the extra space to >> > the >> > + * caller. >> > + */ >> > + [[nodiscard]] static constexpr auto >> > + allocate_at_least(_Alloc& __a, size_type __n) >> > + -> allocation_result<pointer, size_type> >> > + { >> > + static_assert(requires { sizeof(value_type); }, >> > + "allocated object type must be complete"); >> > >> > >> > Does using a requires-expression make a difference here, rather than >> > just sizeof directly? >> >> Just that it writes out the error message attached. > > > Ah yes, the requires-expression means we get a failed static_assert: > > /home/jwakely/gcc/16/include/c++/16.0.1/bits/new_allocator.h:131:23: error: > static assertion failed: cannot allocate incomplete types > 131 | static_assert(requires { sizeof(_Tp); }, "cannot allocate > incomplete types"); > | ^~~~~~~~~~~~~~~~~~~~~~~~~ > * 'false' evaluates to false > > instead of an invalid one that doesn't even get as far as testing the boolean > expression: > > /home/jwakely/gcc/16/include/c++/16.0.1/bits/new_allocator.h:131:23: error: > invalid application of 'sizeof' to incomplete type 'S' > 131 | static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete > types"); > | ^~~~~~~~~~~ > > But then it would be better to improve the existing checks in > allocator::allocate instead of adding another one here. That can be done > separately, so for this patch please don't add a new static_assert, we > already get a diagnostic from the allocate(n) call.
Maybe something like the attached patch.
commit 723a2a1b6ac2e77b4507bad03ec71714ce08e3d6 Author: Jonathan Wakely <[email protected]> AuthorDate: Mon Mar 9 12:15:19 2026 Commit: Jonathan Wakely <[email protected]> CommitDate: Mon Mar 9 13:24:57 2026 libstdc++: Improve diagnostics for std::allocator<incomplete type> Using requires { sizeof(T); } in __new_allocator::allocate gives a better diagnostic when the static_assert fails. We can also reduce the total number of diagnostics due to invalid sizeof(T) and alignof(T) by using the same requires-expression to make the body of the function discarded statement when the static_assert already failed. This fixes a regression in diagnostic quality due to making __new_allocator::allocate constexpr in r16-7271-g7197d0cce70525, which caused a cascade of seven errors instead of just one for std::allocator<incomplete-type>().allocate(1). libstdc++-v3/ChangeLog: * include/bits/allocator.h (allocator::allocate): Use specific feature test macro for constexpr allocate and deallocate. Make consteval path a discarded statement if sizeof(T) is ill-formed. * include/bits/new_allocator.h (__new_allocator::allocate): Use requires-expression for static_cast. Make function body a discarded stament if sizeof(T) is ill-formed. Use if-constexpr for alignment checks. diff --git a/libstdc++-v3/include/bits/allocator.h b/libstdc++-v3/include/bits/allocator.h index 9f9526bd5b01..5f1905d6f5ca 100644 --- a/libstdc++-v3/include/bits/allocator.h +++ b/libstdc++-v3/include/bits/allocator.h @@ -194,6 +194,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION allocate(size_t __n) { if (std::__is_constant_evaluated()) +#if __cpp_concepts + if constexpr (requires { sizeof(_Tp); }) +#endif { if (__builtin_mul_overflow(__n, sizeof(_Tp), &__n)) std::__throw_bad_array_new_length(); diff --git a/libstdc++-v3/include/bits/new_allocator.h b/libstdc++-v3/include/bits/new_allocator.h index 4fe67f99e5c0..edfed00fad28 100644 --- a/libstdc++-v3/include/bits/new_allocator.h +++ b/libstdc++-v3/include/bits/new_allocator.h @@ -128,9 +128,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201103L // _GLIBCXX_RESOLVE_LIB_DEFECTS // 3308. std::allocator<void>().allocate(n) - static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); + static_assert( +#if __cpp_concepts + requires { sizeof(_Tp); }, +#else + sizeof(_Tp) != 0, +#endif + "cannot allocate incomplete types"); #endif +#if __cplusplus >= 201103L && __cpp_concepts + if constexpr (!requires { sizeof(_Tp); }) + return nullptr; // static_assert already failed + else +#endif if (__builtin_expect(__n > this->_M_max_size(), false)) { // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -139,16 +150,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION std::__throw_bad_array_new_length(); std::__throw_bad_alloc(); } - #if __cpp_aligned_new && __cplusplus >= 201103L - if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) + else if constexpr (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { std::align_val_t __al = std::align_val_t(alignof(_Tp)); return static_cast<_Tp*>(_GLIBCXX_OPERATOR_NEW(__n * sizeof(_Tp), __al)); } #endif - return static_cast<_Tp*>(_GLIBCXX_OPERATOR_NEW(__n * sizeof(_Tp))); + else + return static_cast<_Tp*>(_GLIBCXX_OPERATOR_NEW(__n * sizeof(_Tp))); } // __p is not permitted to be a null pointer. @@ -162,7 +173,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif #if __cpp_aligned_new && __cplusplus >= 201103L - if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) + if constexpr (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { _GLIBCXX_OPERATOR_DELETE(_GLIBCXX_SIZED_DEALLOC(__p, __n), std::align_val_t(alignof(_Tp)));
