[libc++] Use [[nodiscard]] for lock_guard, as an extension

[ldionne]

Summary

D64914 added support for applying [[nodiscard]] to constructors. This
commit uses that capability to flag incorrect uses of std::lock_guard
where one forgets to actually create a variable for the lock_guard.

rdar://45790820

[ldionne]

Update the list of entities to which we apply [[nodiscard]]

[EricWF]

libcxx/include/__config

1016 ↗

(On Diff #214155)

What happens when we apply this attribute to a constructor with a compiler that doesn't yet support it?

Does the warning escape the system header?

[xbolva00]

libcxx/include/__config

1016 ↗

(On Diff #214155)

If compiler returns >= 201907L, it have to support nodiscard on ctors.

Hopefully no compiler just bumps it to 201907L and does not support it.

[ldionne]

libcxx/include/__config

1016 ↗

(On Diff #214155)

What happens when we apply this attribute to a constructor with a compiler that doesn't yet support it?

<stdin>:2:14: warning: attribute 'nodiscard' cannot be applied to functions without return value [-Wignored-attributes]

Does the warning escape the system header?

No, which means we could just use _LIBCPP_NODISCARD/_LIBCPP_NODISCARD_EXT on the constructor and let the warning be captured inside the system header. That's what you had in mind to avoid introducing another macro, right? Would you prefer that?

[ldionne]

Avoid introducing a special macro for [[nodiscard]] on constructors.

libcxx/trunk/docs/UsingLibcxx.rst

 * ``mismatch``
 * ``none_of``
 * ``remove_if``
 * ``remove``
 * ``search_n``
 * ``search``
 * ``unique``
 * ``upper_bound``
+* ``lock_guard``'s constructors

libcxx/trunk/include/__mutex_base

 {
 public:
     typedef _Mutex mutex_type;
 
 private:
     mutex_type& __m_;
 public:
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
     explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
         : __m_(__m) {__m_.lock();}
-    _LIBCPP_INLINE_VISIBILITY
+
+    _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
     lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
         : __m_(__m) {}
     _LIBCPP_INLINE_VISIBILITY
     ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
 private:
     lock_guard(lock_guard const&) _LIBCPP_EQUAL_DELETE;
     lock_guard& operator=(lock_guard const&) _LIBCPP_EQUAL_DELETE;

libcxx/trunk/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp

 
 // GCC versions prior to 7.0 don't provide the required [[nodiscard]] attribute.
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6
 
 // AppleClang9 doesn't yet support C++17's implicitly synthesized deduction
 // guides from existing ctors, needed by default_searcher() below.
 // UNSUPPORTED: apple-clang-9
 
-// Test that entities declared [[nodiscard]] as at extension by libc++, are
+// Test that entities declared [[nodiscard]] as an extension by libc++, are
 // only actually declared such when _LIBCPP_ENABLE_NODISCARD is specified.
 
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.pass.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 // MODULES_DEFINES: _LIBCPP_ENABLE_NODISCARD
 #define _LIBCPP_ENABLE_NODISCARD

libcxx/trunk/test/libcxx/thread/thread.lock/thread.lock.guard/nodiscard.fail.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: libcpp-has-no-threads
+
+// [[nodiscard]] on constructors isn't supported by all compilers
+// UNSUPPORTED: clang-6, clang-6, clang-8, clang-9
+// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11
+
+// <mutex>
+
+// template <class Mutex> class lock_guard;
+
+// [[nodiscard]] explicit lock_guard(mutex_type& m);
+// [[nodiscard]] lock_guard(mutex_type& m, adopt_lock_t);
+
+// Test that we properly apply [[nodiscard]] to lock_guard's constructors,
+// which is a libc++ extension.
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_NODISCARD
+#define _LIBCPP_ENABLE_NODISCARD
+#include <mutex>
+
+int main(int, char**) {
+    std::mutex m;
+    std::lock_guard<std::mutex>{m}; // expected-error{{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
+    std::lock_guard<std::mutex>{m, std::adopt_lock}; // expected-error{{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
+    return 0;
+}