[libc++][NFC] Correct comment about P0600 missing node_handle bits

libcxx/docs/Status/Cxx20.rst

 
 .. csv-table::
    :file: Cxx20Papers.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
-   .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class], |sect|\ [mem.poly.allocator.class], and |sect|\ [container.node.overview].
+   .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class] and |sect|\ [mem.poly.allocator.class].
    .. [#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] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
 
 
 .. _issues-status-cxx20:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx20Issues.csv
    :header-rows: 1
    :widths: auto
 
 Last Updated: 24-May-2021

libcxx/test/std/containers/container.node/node_handle.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
+
+// Make sure the various node handles mark their .empty() method with
+// [[nodiscard]] starting with C++20
+
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+
+void test() {
+    {
+        std::map<int, int>::node_type node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+    {
+        std::multimap<int, int>::node_type node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+    {
+        std::set<int> node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+    {
+        std::multiset<int> node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+    {
+        std::unordered_map<int, int> node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+    {
+        std::unordered_multimap<int, int> node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+    {
+        std::unordered_set<int> node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+    {
+        std::unordered_multiset<int> node;
+        node.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    }
+}

libcxx/test/std/containers/container.node/node_handle.pass.cpp

 
 #include <unordered_set>
 #include <unordered_map>
 #include <set>
 #include <map>
 #include "test_macros.h"
 #include "min_allocator.h"
 
-using namespace std;
-
 // [container.node.overview] Table 83.
 template <class K, class T, class C1, class C2, class H1, class H2, class E1, class E2, class A_set, class A_map>
 struct node_compatibility_table
 {
     static constexpr bool value =
-        is_same_v<typename map<K, T, C1, A_map>::node_type,               typename map<K, T, C2, A_map>::node_type> &&
-        is_same_v<typename map<K, T, C1, A_map>::node_type,               typename multimap<K, T, C2, A_map>::node_type> &&
-        is_same_v<typename set<K, C1, A_set>::node_type,                  typename set<K, C2, A_set>::node_type> &&
-        is_same_v<typename set<K, C1, A_set>::node_type,                  typename multiset<K, C2, A_set>::node_type> &&
-        is_same_v<typename unordered_map<K, T, H1, E1, A_map>::node_type, typename unordered_map<K, T, H2, E2, A_map>::node_type> &&
-        is_same_v<typename unordered_map<K, T, H1, E1, A_map>::node_type, typename unordered_multimap<K, T, H2, E2, A_map>::node_type> &&
-        is_same_v<typename unordered_set<K, H1, E1, A_set>::node_type,    typename unordered_set<K, H2, E2, A_set>::node_type> &&
-        is_same_v<typename unordered_set<K, H1, E1, A_set>::node_type,    typename unordered_multiset<K, H2, E2, A_set>::node_type>;
+        std::is_same_v<typename std::map<K, T, C1, A_map>::node_type,               typename std::map<K, T, C2, A_map>::node_type> &&
+        std::is_same_v<typename std::map<K, T, C1, A_map>::node_type,               typename std::multimap<K, T, C2, A_map>::node_type> &&
+        std::is_same_v<typename std::set<K, C1, A_set>::node_type,                  typename std::set<K, C2, A_set>::node_type> &&
+        std::is_same_v<typename std::set<K, C1, A_set>::node_type,                  typename std::multiset<K, C2, A_set>::node_type> &&
+        std::is_same_v<typename std::unordered_map<K, T, H1, E1, A_map>::node_type, typename std::unordered_map<K, T, H2, E2, A_map>::node_type> &&
+        std::is_same_v<typename std::unordered_map<K, T, H1, E1, A_map>::node_type, typename std::unordered_multimap<K, T, H2, E2, A_map>::node_type> &&
+        std::is_same_v<typename std::unordered_set<K, H1, E1, A_set>::node_type,    typename std::unordered_set<K, H2, E2, A_set>::node_type> &&
+        std::is_same_v<typename std::unordered_set<K, H1, E1, A_set>::node_type,    typename std::unordered_multiset<K, H2, E2, A_set>::node_type>;
 };
 
 template <class T> struct my_hash
 {
     using argument_type = T;
-    using result_type = size_t;
+    using result_type = std::size_t;
     my_hash() = default;
-    size_t operator()(const T&) const {return 0;}
+    std::size_t operator()(const T&) const {return 0;}
 };
 
 template <class T> struct my_compare
 {
     my_compare() = default;
     bool operator()(const T&, const T&) const {return true;}
 };
 
struct Static
     Static& operator=(Static&&) = delete;
 };
 
 namespace std
 {
 template <> struct hash<Static>
 {
     using argument_type = Static;
-    using result_type = size_t;
+    using result_type = std::size_t;
     hash() = default;
-    size_t operator()(const Static&) const;
+    std::size_t operator()(const Static&) const;
 };
 }
 
 static_assert(node_compatibility_table<
                   int, int, std::less<int>, std::less<int>, std::hash<int>,
                   std::hash<int>, std::equal_to<int>, std::equal_to<int>,
                   std::allocator<int>,
                   std::allocator<std::pair<const int, int>>>::value,
               "");
 
 static_assert(
     node_compatibility_table<int, int, std::less<int>, my_compare<int>,
                              std::hash<int>, my_hash<int>, std::equal_to<int>,
-                             my_equal<int>, allocator<int>,
-                             allocator<std::pair<const int, int>>>::value,
+                             my_equal<int>, std::allocator<int>,
+                             std::allocator<std::pair<const int, int>>>::value,
     "");
 
 static_assert(node_compatibility_table<
                   Static, int, my_compare<Static>, std::less<Static>,
                   my_hash<Static>, std::hash<Static>, my_equal<Static>,
                   std::equal_to<Static>, min_allocator<Static>,
                   min_allocator<std::pair<const Static, int>>>::value,
               "");