Remove nodiscard annotations from the standard library specification

Various arguments for putting the annotations into the specification

"But I want the annotations to be 'portable' so that my code doesn't break when compiled with an implementation that has the annotations, when the one I used before doesn't have them"

While that's a nice idea,

1. your code is portably broken, regardless of whether all implementations diagnose it
2. you can get all the implementations to warn you by writing a recommendation for when and where they should, and by sending patches to them
3. the recommendation and the patches can be produced without spending LEWG/LWG/WG21 time, and can be done better and faster without spending that time

"But the places where we currently have a [[nodiscard]] are bad bugs unless diagnosed"

Yes, they are. But that's QoI like all other things where failing to do something is (usually) a bad bug. Unless we know something to be really always bad, we risk wasting time chasing a good specification and running into false positives. Is a discarded call to std::async always a bug? Depends on whether you ever actually evaluate the call.

"These annotations are helpful both to users and implementation vendors"

Of course they are. That doesn't mean going through all of our proceducal pipes is an appropriate way to accomplish that.

For every proposal proposing to add more of these annotations, we need to require such a proposal to

1. look at whether STLSTL (you know, MSVC stdlib) already annotates the entity in case, and if not, find out why not
2. run it by the other implementation vendors to have them check whether they think the annotation is feasible and viable

Why waste all that time going through the committee? Why not edit a recommendation document, have vendors look at it and give their feedback on it, look at STLSTL, and send patches to it and the others? You'll get the same implementation vendor feedback, same "portability", and you'll get it faster, without spending the time of WG21, or its subgroups.

What to do instead

As suggested on the reflector,

1. rip out the [[nodiscard]] annotations from the standard
2. don't add more
3. create a separate document containing recommendations where to put [[nodiscard]] in a standard library implementation
4. have implementation vendors look at the revisions of that document periodically
5. edit the document when you have done analysis and implementation work, not otherwise
6. and sure, form either an ad-hoc ARG or a real ARG with a mailing list for people interested in doing this work

Side note about sending patches to implementations

All three of our major library implementations are open source (or even Free Software, for those who insist on terminology). And none of them require going through red tape hoops to accept patches, not even libstdc++, any more.

If you bothered implementing a [[nodiscard]] addition, did you test it? If you did, surely you tested it with an existing testsuite of an implementation? If you didn't, why are we listening to your suggestion to add it? The implementation and testing effort is straightforward, and mandatory for the desired end effect to materialize. So the world cannot skip it, even if ivory tower proposal authors might think it's not their problem.

Wording

Drafting note: the examples are okay, no need to remove the [[nodiscard]] from those.

In [basic.stc.dynamic.general]/2, edit as follows:

[[nodiscard]] void* operator new(std::size_t);
[[nodiscard]] void* operator new(std::size_t, std::align_val_t);
void operator delete(void*) noexcept;
void operator delete(void*, std::size_t) noexcept;
void operator delete(void*, std::align_val_t) noexcept;
void operator delete(void*, std::size_t, std::align_val_t) noexcept;
[[nodiscard]] void* operator new[](std::size_t);
[[nodiscard]] void* operator new[](std::size_t, std::align_val_t);

In [new.syn], edit as follows:

.
.
// 17.6.5, pointer optimization barrier
template [[nodiscard]] constexpr T* launder(T* p) noexcept;
.
.
// 17.6.3, storage allocation and deallocation
[[nodiscard]] void* operator new(std::size_t size);
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
.
.
[[nodiscard]] void* operator new[](std::size_t size);
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
.
.
[[nodiscard]] void* operator new (std::size_t size, void* ptr) noexcept;
[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;

In [new.delete.single], edit as follows:

[[nodiscard]] void* operator new(std::size_t size);
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
.
.
[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment,
const std::nothrow_t&) noexcept;

In [new.delete.array], edit as follows:

[[nodiscard]] void* operator new[](std::size_t size);
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
.
.
[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment,
const std::nothrow_t&) noexcept;

In [new.delete.placement], edit as follows:

[[nodiscard]] void* operator new(std::size_t size, void* ptr) noexcept;
.
.
[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;

In [ptr.launder], edit as follows:

template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;

In [memory.syn], edit as follows:

template<size_t N, class T>
[[nodiscard]] constexpr T* assume_aligned(T* ptr);

In [ptr.align], edit as follows:

template<size_t N, class T>
[[nodiscard]] constexpr T* assume_aligned(T* ptr);

In [allocator.traits.general], edit as follows:

.
.
[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n);
[[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n,
const_void_pointer hint);

In [allocator.traits.members], edit as follows:

[[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n);
.
.
[[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);

In [allocator.traits.other], edit as follows:

template<class Allocator>
[[nodiscard]] constexpr allocation_result<typename allocator_traits<Allocator>::pointer>
allocate_at_least(Allocator& a, size_t n);

In [default.allocator.general], edit as follows:

[[nodiscard]] constexpr T* allocate(size_t n);
[[nodiscard]] constexpr allocation_result allocate_at_least(size_t n);

In [allocator.members], edit as follows:

[[nodiscard]] constexpr T* allocate(size_t n);
.
.
[[nodiscard]] constexpr allocation_result allocate_at_least(size_t n);

In [mem.res.class.general], edit as follows:

[[nodiscard]] void* allocate(size_t bytes, size_t alignment = max_align);

In [mem.res.public], edit as follows:

[[nodiscard]] void* allocate(size_t bytes, size_t alignment = max_align);

In [mem.poly.allocator.class.general], edit as follows:

[[nodiscard]] Tp* allocate(size_t n);
.
.
[[nodiscard]] void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
.
.
template<class T> [[nodiscard]] T* allocate_object(size_t n = 1);
.
.
template<class T, class... CtorArgs> [[nodiscard]] T* new_object(CtorArgs&&... ctor_args);

In [mem.poly.allocator.mem], edit as follows:

[[nodiscard]] Tp* allocate(size_t n);
.
.
[[nodiscard]] void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
.
.
template<class T>
[[nodiscard]] T* allocate_object(size_t n = 1);
.
.
template<class T, class... CtorArgs>
[[nodiscard]] T* new_object(CtorArgs&&... ctor_args);

In [allocator.adaptor.syn], edit as follows:

[[nodiscard]] pointer allocate(size_type n);
[[nodiscard]] pointer allocate(size_type n, const_void_pointer hint);

In [allocator.adaptor.members], edit as follows:

[[nodiscard]] pointer allocate(size_type n);
.
.
[[nodiscard]] pointer allocate(size_type n, const_void_pointer hint);

In [stacktrace.basic.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [stacktrace.basic.obs], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [forward], edit as follows:

template<class T, class U>
  [[nodiscard]] constexpr auto forward_like(U&& x) noexcept -> see below ;

In [basic.string.general], edit as follows:

[[nodiscard]] constexpr bool empty() const noexcept;

In [string.capacity], edit as follows:

[[nodiscard]] constexpr bool empty() const noexcept;

In [string.view.template.general], edit as follows:

[[nodiscard]] constexpr bool empty() const noexcept;

In [string.view.capacity], edit as follows:

[[nodiscard]] constexpr bool empty() const noexcept;

In [container.node.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [container.node.observers], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [array.overview], edit as follows:

[[nodiscard]] constexpr bool empty() const noexcept;

In [deque.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [forward.list.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [list.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [vector.overview], edit as follows:

[[nodiscard]] constexpr bool empty() const noexcept;

In [vector.bool], edit as follows:

[[nodiscard]] constexpr bool empty() const noexcept;

In [map.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [multimap.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;

In [set.overview], edit as follows:

[[nodiscard]] bool empty() const noexcept;