[lbc++] Implement the rest of P0600R1 (nodiscard in the library)

[ldionne]

LGTM w/ comments applied and CI passing.

libcxx/test/std/utilities/utility/mem.res/nodiscard.verify.cpp

2

Can you please make this // UNSUPPORTED: c++03, c++11, c++14, c++17 so that this is a conformance test without any extensions in it? Then, add another test in libcxx/test/libcxx/ .... that checks the extension in C++17 mode. This is nitpicky, but I would like to keep the test for the extension separate.

13

Please add the synopsis of the functions you're checking for nodiscardness.

[philnik]

Address comments

[philnik]

Update tests

[philnik]

Rebased

libcxx/docs/ReleaseNotes.rst

 - P2445R1 - ``std::forward_like``
 - P2273R3 - Making ``std::unique_ptr`` constexpr
 - P0591R4 - Utility functions to implement uses-allocator construction
 - P2291R3 - Add Constexpr Modifiers to Functions ``to_chars`` and
   ``from_chars`` for Integral Types in ``<charconv>`` Header
 - P0220R1 - Adopt Library Fundamentals V1 TS Components for C++17
 - P0482R6 - char8_t: A type for UTF-8 characters and strings
 - P2438R2 - ``std::string::substr() &&``
+- P0600R1 - ``nodiscard`` in the library
 
 Improvements and New Features
 -----------------------------
 - Declarations of ``std::c8rtomb()`` and ``std::mbrtoc8()`` from P0482R6 are
   now provided when implementations in the global namespace are provided by
   the C library.
 - Implemented ``<memory_resource>`` header from C++17
 

libcxx/docs/Status/Cxx20.rst

 .. csv-table::
    :file: Cxx20Papers.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
    .. [#note-P0591] P0591: The changes in [mem.poly.allocator.mem] are missing.
-   .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class] and |sect|\ [mem.poly.allocator.class].
    .. [#note-P0645] P0645: The paper is implemented but still marked as an incomplete feature
       (the feature-test macro is not set and the libary is only available when built with ``-fexperimental-library``).
       Not yet implemented LWG-issues will cause API and ABI breakage.
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
    .. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
    .. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
    .. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.
    .. [#note-P2231] P2231: Optional is complete. The changes to variant haven't been implemented yet.

libcxx/docs/Status/Cxx20Papers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version"
 "`P0463R1 <https://wg21.link/P0463R1>`__","LWG","Endian just Endian","Toronto","|Complete|","7.0"
 "`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","|Complete|","15.0"
 "","","","","",""
 "`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
 "`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
 "`P0202R3 <https://wg21.link/P0202R3>`__","LWG","Add constexpr modifiers to functions in <algorithm> and <utility> Headers","Albuquerque","|Complete|","12.0"
 "`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|In Progress|","7.0"
 "`P0439R0 <https://wg21.link/P0439R0>`__","LWG","Make ``std::memory_order``\  a scoped enumeration","Albuquerque","|Complete|",""
 "`P0457R2 <https://wg21.link/P0457R2>`__","LWG","String Prefix and Suffix Checking","Albuquerque","|Complete|","6.0"
 "`P0550R2 <https://wg21.link/P0550R2>`__","LWG","Transformation Trait ``remove_cvref``\ ","Albuquerque","|Complete|","6.0"
-"`P0600R1 <https://wg21.link/P0600R1>`__","LWG","nodiscard in the Library","Albuquerque","|In Progress| [#note-P0600]_","7.0"
+"`P0600R1 <https://wg21.link/P0600R1>`__","LWG","nodiscard in the Library","Albuquerque","|Complete|","16.0"
 "`P0616R0 <https://wg21.link/P0616R0>`__","LWG","de-pessimize legacy <numeric> algorithms with std::move","Albuquerque","|Complete|","12.0"
 "`P0653R2 <https://wg21.link/P0653R2>`__","LWG","Utility to convert a pointer to a raw pointer","Albuquerque","|Complete|","6.0"
 "`P0718R2 <https://wg21.link/P0718R2>`__","LWG","Atomic shared_ptr","Albuquerque","",""
 "`P0767R1 <https://wg21.link/P0767R1>`__","CWG","Deprecate POD","Albuquerque","|Complete|","7.0"
 "`P0768R1 <https://wg21.link/P0768R1>`__","CWG","Library Support for the Spaceship (Comparison) Operator","Albuquerque","|Complete|",""
 "`P0777R1 <https://wg21.link/P0777R1>`__","LWG","Treating Unnecessary ``decay``\ ","Albuquerque","|Complete|","7.0"
 "`P0122R7 <https://wg21.link/P0122R7>`__","LWG","<span>","Jacksonville","|Complete|","7.0"
 "`P0355R7 <https://wg21.link/P0355R7>`__","LWG","Extending chrono to Calendars and Time Zones","Jacksonville","|In Progress|",""

libcxx/include/__memory_resource/memory_resource.h

 // [mem.res.class]
 
 class _LIBCPP_TYPE_VIS memory_resource {
   static const size_t __max_align = alignof(max_align_t);
 
 public:
   virtual ~memory_resource();
 
+  _LIBCPP_NODISCARD_AFTER_CXX17
   [[using __gnu__: __returns_nonnull__, __alloc_size__(2), __alloc_align__(3)]] _LIBCPP_HIDE_FROM_ABI void*
   allocate(size_t __bytes, size_t __align = __max_align) {
     return do_allocate(__bytes, __align);
   }
 
   [[__gnu__::__nonnull__]] _LIBCPP_HIDE_FROM_ABI void
   deallocate(void* __p, size_t __bytes, size_t __align = __max_align) {
     do_deallocate(__p, __bytes, __align);

libcxx/include/__memory_resource/polymorphic_allocator.h

public:
   template <class _Tp>
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(const polymorphic_allocator<_Tp>& __other) noexcept
       : __res_(__other.resource()) {}
 
   polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
 
   // [mem.poly.allocator.mem]
 
-  _LIBCPP_HIDE_FROM_ABI _ValueType* allocate(size_t __n) {
+  _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _ValueType* allocate(size_t __n) {
     if (__n > __max_size()) {
       __throw_bad_array_new_length();
     }
     return static_cast<_ValueType*>(__res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType)));
   }
 
   _LIBCPP_HIDE_FROM_ABI void deallocate(_ValueType* __p, size_t __n) {
     _LIBCPP_ASSERT(__n <= __max_size(), "deallocate called for size which exceeds max_size()");

libcxx/test/libcxx/mem/mem.res/nodiscard.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// check that functions are marked [[nodiscard]] as an extension in C++17
+
+// [[nodiscard]] std::pmr::memory_resource::allocate(size_t, size_t);
+// [[nodiscard]] std::pmr::polymorphic_allocator<T>::allocate(size_t, size_t);
+
+#include <memory_resource>
+
+void f() {
+  std::pmr::memory_resource* res = nullptr;
+  res->allocate(0);    // expected-warning {{ignoring return value of function}}
+  res->allocate(0, 1); // expected-warning {{ignoring return value of function}}
+
+  std::pmr::polymorphic_allocator<int> poly;
+  poly.allocate(0); // expected-warning {{ignoring return value of function}}
+}

libcxx/test/libcxx/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_in_geometric_progression.pass.cpp

 
 #include "count_new.h"
 
 int main(int, char**) {
   globalMemCounter.reset();
   std::pmr::monotonic_buffer_resource mono;
 
   for (int i = 0; i < 100; ++i) {
-    mono.allocate(1);
+    (void)mono.allocate(1);
     assert(globalMemCounter.last_new_size < 1000000000);
     mono.release();
     assert(globalMemCounter.checkOutstandingNewEq(0));
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate.pass.cpp

void testAllocForSizeThrows() {
   Alloc a(&R);
 
   // Test that allocating exactly the max size does not throw.
   size_t maxSize = Traits::max_size(a);
   size_t sizeTypeMax = std::numeric_limits<std::size_t>::max();
   if (maxSize != sizeTypeMax) {
     // Test that allocating size_t(~0) throws bad alloc.
     try {
-      a.allocate(sizeTypeMax);
+      (void)a.allocate(sizeTypeMax);
       assert(false);
     } catch (const std::exception&) {
     }
 
     // Test that allocating even one more than the max size does throw.
     size_t overSize = maxSize + 1;
     try {
-      a.allocate(overSize);
+      (void)a.allocate(overSize);
       assert(false);
     } catch (const std::exception&) {
     }
   }
 }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 int main(int, char**) {

libcxx/test/std/utilities/utility/mem.res/mem.res.global/null_memory_resource.pass.cpp

// Different types
     assert(!r1.is_equal(r2));
   }
 }
 
 void test_allocate() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   DisableAllocationGuard g; // null_memory_resource shouldn't allocate.
   try {
-    std::pmr::null_memory_resource()->allocate(1);
+    (void)std::pmr::null_memory_resource()->allocate(1);
     assert(false);
   } catch (std::bad_alloc const&) {
     // do nothing
   } catch (...) {
     assert(false);
   }
 #endif
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_with_initial_size.pass.cpp

 #include "test_macros.h"
 
 void test(size_t initial_buffer_size) {
   globalMemCounter.reset();
 
   auto mono1 = std::pmr::monotonic_buffer_resource(initial_buffer_size, std::pmr::new_delete_resource());
   assert(globalMemCounter.checkNewCalledEq(0));
 
-  mono1.allocate(1, 1);
+  (void)mono1.allocate(1, 1);
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledEq(1));
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkLastNewSizeGe(initial_buffer_size));
 
-  mono1.allocate(initial_buffer_size - 1, 1);
+  (void)mono1.allocate(initial_buffer_size - 1, 1);
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledEq(1));
 }
 
 int main(int, char**) {
   test(1);
   test(8);
   test(10);
   test(100);
   test(256);
   test(1000);
   test(1024);
   test(1000000);
   assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res/mem.res.public/allocate.pass.cpp

int main(int, char**) {
   }
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     TestResource R2;
     auto& P2                      = R2.getController();
     P2.throw_on_alloc             = true;
     std::pmr::memory_resource& M2 = R2;
     try {
-      M2.allocate(42);
+      (void)M2.allocate(42);
       assert(false);
     } catch (TestException const&) {
       // do nothing.
     } catch (...) {
       assert(false);
     }
   }
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/nodiscard.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// check that functions are marked [[nodiscard]]
+
+// [[nodiscard]] std::pmr::memory_resource::allocate(size_t, size_t);
+// [[nodiscard]] std::pmr::polymorphic_allocator<T>::allocate(size_t, size_t);
+
+#include <memory_resource>
+
+void f() {
+  std::pmr::memory_resource* res = nullptr;
+  res->allocate(0);    // expected-warning {{ignoring return value of function}}
+  res->allocate(0, 1); // expected-warning {{ignoring return value of function}}
+
+  std::pmr::polymorphic_allocator<int> poly;
+  poly.allocate(0); // expected-warning {{ignoring return value of function}}
+}