[libc++] Add nodiscard attribute to std::make_unique/std::make_shared

libcxx/include/memory

@@ -566,15 +566,15 @@ class bad_weak_ptr
 };
 
 template<class T, class... Args>
-constexpr unique_ptr<T> make_unique(Args&&... args);                            // C++14, constexpr since C++23
+[[nodiscard]] constexpr unique_ptr<T> make_unique(Args&&... args);                            // C++14, constexpr since C++23
 template<class T>
-constexpr unique_ptr<T> make_unique(size_t n);                                  // C++14, constexpr since C++23
+[[nodiscard]] constexpr unique_ptr<T> make_unique(size_t n);                                  // C++14, constexpr since C++23
 template<class T, class... Args> unspecified   make_unique(Args&&...) = delete; // C++14, T == U[N]
 
 template<class T>
-  constexpr unique_ptr<T> make_unique_for_overwrite();                        // T is not array, C++20, constexpr since C++23
+  [[nodiscard]] constexpr unique_ptr<T> make_unique_for_overwrite();                        // T is not array, C++20, constexpr since C++23
 template<class T>
-  constexpr unique_ptr<T> make_unique_for_overwrite(size_t n);                // T is U[], C++20, constexpr since C++23
+  [[nodiscard]] constexpr unique_ptr<T> make_unique_for_overwrite(size_t n);                // T is U[], C++20, constexpr since C++23
 template<class T, class... Args>
   unspecified make_unique_for_overwrite(Args&&...) = delete;                  // T is U[N], C++20
 
@@ -702,39 +702,39 @@ template<class E, class T, class Y>
 template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;
 
 template<class T, class... Args>
-    shared_ptr<T> make_shared(Args&&... args); // T is not an array
+    [[nodiscard]] shared_ptr<T> make_shared(Args&&... args); // T is not an array
 template<class T, class A, class... Args>
-    shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not an array
+    [[nodiscard]] shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not an array
 
 template<class T>
-    shared_ptr<T> make_shared(size_t N); // T is U[] (since C++20)
+    [[nodiscard]] shared_ptr<T> make_shared(size_t N); // T is U[] (since C++20)
 template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[] (since C++20)
+    [[nodiscard]] shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[] (since C++20)
 
 template<class T>
-    shared_ptr<T> make_shared(); // T is U[N] (since C++20)
+    [[nodiscard]] shared_ptr<T> make_shared(); // T is U[N] (since C++20)
 template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a); // T is U[N] (since C++20)
+    [[nodiscard]] shared_ptr<T> allocate_shared(const A& a); // T is U[N] (since C++20)
 
 template<class T>
-    shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
+    [[nodiscard]] shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
 template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
+    [[nodiscard]] shared_ptr<T> allocate_shared(const A& a, size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
 
 template<class T> shared_ptr<T>
-    make_shared(const remove_extent_t<T>& u); // T is U[N] (since C++20)
+    [[nodiscard]] make_shared(const remove_extent_t<T>& u); // T is U[N] (since C++20)
 template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T is U[N] (since C++20)
+    [[nodiscard]] shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T is U[N] (since C++20)
 
 template<class T>
-  shared_ptr<T> make_shared_for_overwrite();                                  // T is not U[], C++20
+  [[nodiscard]] shared_ptr<T> make_shared_for_overwrite();                                  // T is not U[], C++20
 template<class T, class A>
-  shared_ptr<T> allocate_shared_for_overwrite(const A& a);                    // T is not U[], C++20
+  [[nodiscard]] shared_ptr<T> allocate_shared_for_overwrite(const A& a);                    // T is not U[], C++20
 
 template<class T>
-  shared_ptr<T> make_shared_for_overwrite(size_t N);                          // T is U[], C++20
+  [[nodiscard]] shared_ptr<T> make_shared_for_overwrite(size_t N);                          // T is U[], C++20
 template<class T, class A>
-  shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);          // T is U[], C++20
+  [[nodiscard]] shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);          // T is U[], C++20
 
 template<class T>
 class weak_ptr