[RFC] Add _LIBCPP_NO_DISCARD and apply it to `Container::empty()`, `unique_ptr<T>::release()`, and `Lockable::try_lock()`

[EricWF]

Summary

This patch adds the _LIBCPP_NO_DISCARD macro and applies it to various functions including:

• unique_ptr<T>::release()
• The empty(), size(), capacity() and max_size() methods of STL Containers and std::string.
• try_lock(), try_lock_for() and try_lock_until() of lockable types.

I just want to check that we agree on the general direction of this patch. Specifically that libc++ should be free to apply no_discard where we feel appropriate.

Additional suggestions welcome!

This patch fixes PR30898 (https://llvm.org/bugs/show_bug.cgi?id=30898)

[chandlerc]

I think we want dedicated macros to disable each added [[nodiscard]]. The reason is that as you add each one, users will have to roll out cleanups for the new warnings. This may be hard to do quickly and cause problems updating libc++ for users with -Werror in their build. I'd prefer it if users can initially add a macro to disable the attribute until their cleanup is complete.

There should also be a page documenting all of the APIs that use this and the macros to control them.

[mclow.lists]

In D26596#593948, @chandlerc wrote:

I think we want dedicated macros to disable each added [[nodiscard]].

My concern here is that I expect that there will be a lot of these.
Off the top of my head, I can name:

• Every smart pointer's get() and release()
• Every container's empty()
• A bunch of algorithms (find(), find_if(), search(), and lower/upper_bound() leap to mind, but that's not an exhaustive list)

[mclow.lists]

Note: I'm not unsympathetic to the situation that Chandler describes; I just don't want to manage a potentially unbounded (but probably more than 20) set of macros.

[EricWF]

• Allow groups of no-discard checks to be enabled/disabled using group specific macros. (As requested by @chandlerc)
• Add documentation for _LIBCPP_NO_DISCARD and friends.
• Apply no-discard checks in more places to show new feature macro example.

@chandlerc Would this approach be sufficient?

[EricWF]

• Add missing newlines in added tests.

[EricWF]

• Apply no-discard to string_view::empty() and friends.
• Fix discarded use of unique_ptr<T>::release() within libc++.

[EricWF]

• Fix even more instances of unique_ptr<T>::release() with a discarded value. Hopefully this is the last of them.

[EricWF]

• Fix tests containing discarded values.
• Fix two more instances of discarded unique_ptr<T>::release() in the headers.

[EricWF]

• Add [[no_discard]] to various smart pointer observers including get() and operator*().

[EricWF]

Add final touches. This patch is ready to go.

@chandlerc mentioned he would still like to see more per-function granularity for enabling/disabling the libc++ [[nodiscard]] macro in order to ease adoption in large code bases. However I'm concerned about the cost of maintaining 100+ user-visible configuration macros. This current patch attempts to find a happy medium by grouping similar functions into a single macro; which can be sub-divided further if needed.

As a general rule functions where [[nodiscard]] may yield false positives (ie unique_ptr::release()) should always have their own group, since fixing the false-positives is a stylistic change. Functions where a discarded value is always a bug, either for correctness reasons (ie try_lock()) or because the call has no side-effects (ie string::empty), may be grouped together as appropriate; Warnings generated by these groups should either be rare or high priority bugs. Dividing groups in this manner attempts to maximize adaptability while being reasonably maintainable.

@mclow.lists Any last words?

[mclow.lists]

Since we've implemented P0600, I believe that this patch is out of date.
The correct macro is _LIBCPP_NODISCARD_AFTER_CXX17, and I think that several of these cases are now handled.

docs/UsingLibcxx.rst

**_LIBCPP_DEBUG**:
   the program.
 
   Note that this option has no effect on libc++'s ABI
 
 **_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS**:
   This macro is used to enable -Wthread-safety annotations on libc++'s
   ``std::mutex`` and ``std::lock_guard``. By default these annotations are
   disabled and must be manually enabled by the user.
+
+**_LIBCPP_NO_DISCARD**
+  This macro is used to annotate various libc++ functions as having a
+  non-discardable return value. This macro is enabled by default.
+
+  **Overriding**: To fully disable libc++'s no-discard attribute users can
+  define `_LIBCPP_DISABLE_NO_DISCARD` before including any headers. It's also
+  possible to disable groups of no-discard checks by defining one of the
+  macros below:
+
+    * **_LIBCPP_DISABLE_NO_DISCARD_CONTAINER_OBSERVERS**: Disables
+      no-discard on non-modifying container operations such as the ``size()``,
+      ``empty()``, and ``capacity()`` methods of ``std::vector`` or
+      ``std::string``.
+
+    * **_LIBCPP_DISABLE_NO_DISCARD_SMART_PTR_OBSERVERS**: Disables no-discard
+      on non-modifying smart pointer operations such as ``get()`` or
+      ``operator*()``.
+
+    * **_LIBCPP_DISABLE_NO_DISCARD_TRY_LOCK**: Disables no-discard on the
+      ``try_lock()``, ``try_lock_for()``, and ``try_lock_until()``
+      members of lockable types.
+
+    * **_LIBCPP_DISABLE_NO_DISCARD_UNIQUE_PTR_RELEASE**: Disables no-discard on
+      ``std::unique_ptr<T>::release()``.

include/__config

 #endif
 
 #if __has_attribute(require_constant_initialization)
 #define _LIBCPP_SAFE_STATIC __attribute__((__require_constant_initialization__))
 #else
 #define _LIBCPP_SAFE_STATIC
 #endif
 
+#if __has_attribute(__warn_unused_result__) || _GNUC_VER > 408
+# define _LIBCPP_NO_DISCARD_INTERNAL __attribute__((__warn_unused_result__))
+#else
+# define _LIBCPP_NO_DISCARD_INTERNAL
+#endif
+
+#ifndef _LIBCPP_DISABLE_NO_DISCARD
+# define _LIBCPP_NO_DISCARD _LIBCPP_NO_DISCARD_INTERNAL
+#else
+# define _LIBCPP_NO_DISCARD
+#endif
+
+#if !defined(_LIBCPP_DISABLE_NO_DISCARD_CONTAINER_OBSERVERS)
+# define _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_NO_DISCARD
+#else
+# define _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS
+#endif
+
 #if !__has_builtin(__builtin_addressof) && _GNUC_VER < 700
 #define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
 #if defined(_WIN32) || defined(_NEWLIB_VERSION)
 #define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
 #endif
 #endif
 
 #endif // __cplusplus
 
 #endif // _LIBCPP_CONFIG

include/__hash_table

 #endif  // _LIBCPP_NO_EXCEPTIONS
             __deallocate(__cache);
         }
         const_iterator __i = __u.begin();
         while (__u.size() != 0)
         {
             __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_));
             __node_insert_multi(__h.get());
-            __h.release();
+            (void)__h.release();
         }
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
 __hash_table<_Tp, _Hash, _Equal, _Alloc>&
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_impl(_Args&&... __args)
 {
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     pair<iterator, bool> __r = __node_insert_unique(__h.get());
     if (__r.second)
-        __h.release();
+        (void)__h.release();
     return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_multi(_Args&&... __args)
 {
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     iterator __r = __node_insert_multi(__h.get());
-    __h.release();
+    (void)__h.release();
     return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
         const_iterator __p, _Args&&... __args)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "unordered container::emplace_hint(const_iterator, args...) called with an iterator not"
         " referring to this unordered container");
 #endif
     __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     iterator __r = __node_insert_multi(__p, __h.get());
-    __h.release();
+    (void)__h.release();
     return __r;
 }
 
 #else // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const __container_value_type& __x)
 {
     __node_holder __h = __construct_node(__x);
     iterator __r = __node_insert_multi(__h.get());
-    __h.release();
+    (void)__h.release();
     return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
                                                          const __container_value_type& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "unordered container::insert(const_iterator, lvalue) called with an iterator not"
         " referring to this unordered container");
 #endif
     __node_holder __h = __construct_node(__x);
     iterator __r = __node_insert_multi(__p, __h.get());
-    __h.release();
+    (void)__h.release();
     return __r;
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n)

include/__mutex_base

 #ifndef _LIBCPP_THREAD_SAFETY_ANNOTATION
 #  ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
 #    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
 #  else
 #    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
 #  endif
 #endif  // _LIBCPP_THREAD_SAFETY_ANNOTATION
 
+#ifndef _LIBCPP_DISABLE_NO_DISCARD_TRY_LOCK
+# define _LIBCPP_NO_DISCARD_TRY_LOCK _LIBCPP_NO_DISCARD
+#else
+# define _LIBCPP_NO_DISCARD_TRY_LOCK
+#endif
+
 class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex
 {
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
     __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
 #else
     __libcpp_mutex_t __m_;
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
     constexpr mutex() _NOEXCEPT _LIBCPP_DEFAULT
 #else
     mutex() _NOEXCEPT {__m_ = (__libcpp_mutex_t)_LIBCPP_MUTEX_INITIALIZER;}
 #endif
     ~mutex();
 
 private:
     mutex(const mutex&);// = delete;
     mutex& operator=(const mutex&);// = delete;
 
 public:
     void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability());
+    _LIBCPP_NO_DISCARD_TRY_LOCK
     bool try_lock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
     void unlock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
 
     typedef __libcpp_mutex_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
 };
 
 struct _LIBCPP_TYPE_VIS defer_lock_t {};
unique_lock& operator=(unique_lock&& __u) _NOEXCEPT
             __u.__m_ = nullptr;
             __u.__owns_ = false;
             return *this;
         }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     void lock();
-    bool try_lock();
+    _LIBCPP_NO_DISCARD_TRY_LOCK bool try_lock();
 
     template <class _Rep, class _Period>
+        _LIBCPP_NO_DISCARD_TRY_LOCK
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
     template <class _Clock, class _Duration>
+        _LIBCPP_NO_DISCARD_TRY_LOCK
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
 
     void unlock();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(unique_lock& __u) _NOEXCEPT
     {
         _VSTD::swap(__m_, __u.__m_);

include/algorithm

                 *__j2 = _VSTD::move(*__first1);
             }
             else
             {
                 ::new(__j2) value_type(_VSTD::move(*__first1));
                 __d.__incr((value_type*)0);
             }
         }
-        __h.release();
+        (void)__h.release();
     }
 }
 
 template <class _Compare, class _RandomAccessIterator>
 void
 __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
     // _Compare is known to be a reference type

     __destruct_n __d(0);
     unique_ptr<value_type, __destruct_n&> __h(__result, __d);
     for (; true; ++__result)
     {
         if (__first1 == __last1)
         {
             for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0))
                 ::new (__result) value_type(_VSTD::move(*__first2));
-            __h.release();
+            (void)__h.release();
             return;
         }
         if (__first2 == __last2)
         {
             for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0))
                 ::new (__result) value_type(_VSTD::move(*__first1));
-            __h.release();
+            (void)__h.release();
             return;
         }
         if (__comp(*__first2, *__first1))
         {
             ::new (__result) value_type(_VSTD::move(*__first2));
             __d.__incr((value_type*)0);
             ++__first2;
         }

         }
         else
         {
             ::new(__first2) value_type(_VSTD::move(*__first1));
             __d.__incr((value_type*)0);
             ++__first2;
             ::new(__first2) value_type(_VSTD::move(*__last1));
         }
-        __h2.release();
+        (void)__h2.release();
         return;
     }
     if (__len <= 8)
     {
         __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp);
         return;
     }
     typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;

include/deque

     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return const_reverse_iterator(__base::end());}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend()   const _NOEXCEPT
         {return const_reverse_iterator(__base::begin());}
 
     // capacity:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __base::size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT
         {return __alloc_traits::max_size(__base::__alloc());}
     void resize(size_type __n);
     void resize(size_type __n, const value_type& __v);
     void shrink_to_fit() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __base::size() == 0;}
 
     // element access:
     _LIBCPP_INLINE_VISIBILITY
     reference operator[](size_type __i);
     _LIBCPP_INLINE_VISIBILITY
     const_reference operator[](size_type __i) const;
     _LIBCPP_INLINE_VISIBILITY

             __buf(max<size_type>(2 * __base::__map_.capacity(), 1),
                   0, __base::__map_.__alloc());
 
         typedef __allocator_destructor<_Allocator> _Dp;
         unique_ptr<pointer, _Dp> __hold(
             __alloc_traits::allocate(__a, __base::__block_size),
                 _Dp(__a, __base::__block_size));
         __buf.push_back(__hold.get());
-        __hold.release();
+        (void)__hold.release();
     
         for (typename __base::__map_pointer __i = __base::__map_.begin();
                 __i != __base::__map_.end(); ++__i)
             __buf.push_back(*__i);
         _VSTD::swap(__base::__map_.__first_, __buf.__first_);
         _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
         _VSTD::swap(__base::__map_.__end_, __buf.__end_);
         _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());

                   __base::__map_.size(),
                   __base::__map_.__alloc());
 
         typedef __allocator_destructor<_Allocator> _Dp;
         unique_ptr<pointer, _Dp> __hold(
             __alloc_traits::allocate(__a, __base::__block_size),
                 _Dp(__a, __base::__block_size));
         __buf.push_back(__hold.get());
-        __hold.release();
+        (void)__hold.release();
 
         for (typename __base::__map_pointer __i = __base::__map_.end();
                 __i != __base::__map_.begin();)
             __buf.push_front(*--__i);
         _VSTD::swap(__base::__map_.__first_, __buf.__first_);
         _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
         _VSTD::swap(__base::__map_.__end_, __buf.__end_);
         _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());

include/ext/hash_map

 _Tp&
 hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
 {
     iterator __i = find(__k);
     if (__i != end())
         return __i->second;
     __node_holder __h = __construct_node(__k);
     pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
-    __h.release();
+    (void)__h.release();
     return __r.first->second;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
      hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)

include/forward_list

iterator       before_begin() _NOEXCEPT
         {return       iterator(base::__before_begin());}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator before_begin() const _NOEXCEPT
         {return const_iterator(base::__before_begin());}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cbefore_begin() const _NOEXCEPT
         {return const_iterator(base::__before_begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
         {return base::__before_begin()->__next_ == nullptr;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT
         {return numeric_limits<size_type>::max();}
 
     _LIBCPP_INLINE_VISIBILITY
     reference       front()       {return base::__before_begin()->__next_->__value_;}
     _LIBCPP_INLINE_VISIBILITY
     const_reference front() const {return base::__before_begin()->__next_->__value_;}
 

include/list

#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     void assign(initializer_list<value_type> __il)
         {assign(__il.begin(), __il.end());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT     {return base::__sz();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT         {return base::empty();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT
         {return numeric_limits<difference_type>::max();}
 
     _LIBCPP_INLINE_VISIBILITY
           iterator begin() _NOEXCEPT        {return base::begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const _NOEXCEPT {return base::begin();}
     _LIBCPP_INLINE_VISIBILITY
if (__n > 0)
         __hold->__prev_ = 0;
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __r = iterator(__hold->__as_link(), this);
 #else
         __r = iterator(__hold->__as_link());
 #endif
-        __hold.release();
+        (void)__hold.release();
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
                 __e.__ptr_->__next_ = __hold->__as_link();
                 __hold->__prev_ = __e.__ptr_;
-                __hold.release();
+                (void)__hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
if (__f != __l)
         __hold->__prev_ = 0;
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __r = iterator(__hold.get()->__as_link(), this);
 #else
         __r = iterator(__hold.get()->__as_link());
 #endif
-        __hold.release();
+        (void)__hold.release();
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (++__f; __f != __l; ++__f, (void) ++__e, (void) ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
-                __hold.release();
+                (void)__hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));

 {
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_pointer __nl = __hold->__as_link();
     __link_nodes_at_front(__nl, __nl);
     ++base::__sz();
-    __hold.release();
+    (void)__hold.release();
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_back(const value_type& __x)
 {
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
-    __hold.release();
+    (void)__hold.release();
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_front(value_type&& __x)
 {
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
-    __hold.release();
+    (void)__hold.release();
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_back(value_type&& __x)
 {
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
-    __hold.release();
+    (void)__hold.release();
 }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 typename list<_Tp, _Alloc>::reference
 list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
#endif
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __hold->__prev_ = 0;
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_pointer __nl = __hold.get()->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
     ++base::__sz();
-    __hold.release();
+    (void)__hold.release();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(__nl, this);
 #else
     return iterator(__nl);
 #endif
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
#endif
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __hold->__prev_ = 0;
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_pointer __nl = __hold->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
     ++base::__sz();
-    __hold.release();
+    (void)__hold.release();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(__nl, this);
 #else
     return iterator(__nl);
 #endif
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
-                __hold.release();
+                (void)__hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
-                __hold.release();
+                (void)__hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));

include/locale

                        2 * __cur_cap : numeric_limits<size_t>::max();
     if (__new_cap == 0)
         __new_cap = sizeof(_Tp);
     size_t __n_off = static_cast<size_t>(__n - __b.get());
     _Tp* __t = (_Tp*)realloc(__owns ? __b.get() : 0, __new_cap);
     if (__t == 0)
         __throw_bad_alloc();
     if (__owns)
-        __b.release();
+        (void)__b.release();
     __b = unique_ptr<_Tp, void(*)(void*)>(__t, free);
     __new_cap /= sizeof(_Tp);
     __n = __b.get() + __n_off;
     __e = __b.get() + __new_cap;
 }
 
 // true == success
 template <class _CharT, class _InputIterator>

include/map

     const_iterator cbegin() const _NOEXCEPT {return begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend() const _NOEXCEPT {return end();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
 
     mapped_type& operator[](const key_type& __k);
 #ifndef _LIBCPP_CXX03_LANG
     mapped_type& operator[](key_type&& __k);
 #endif
 
           mapped_type& at(const key_type& __k);

     const_iterator cbegin()  const _NOEXCEPT {return begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend() const _NOEXCEPT {return end();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
     _LIBCPP_INLINE_VISIBILITY
     key_compare    key_comp() const {return __tree_.value_comp().key_comp();}
     _LIBCPP_INLINE_VISIBILITY
     value_compare  value_comp() const

include/memory

 
 #include <__undef_min_max>
 #include <__undef___deallocate>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#ifndef _LIBCPP_DISABLE_NO_DISCARD_SMART_PTR_OBSERVERS
+# define _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_NO_DISCARD
+#else
+# define _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ValueType>
 inline _LIBCPP_ALWAYS_INLINE
 _ValueType __libcpp_relaxed_load(_ValueType const* __value) {
 #if !defined(_LIBCPP_HAS_NO_THREADS) && \
     defined(__ATOMIC_RELAXED) &&        \
     (__has_builtin(__atomic_load_n) || _GNUC_VER >= 407)

     _LIBCPP_INLINE_VISIBILITY ~unique_ptr() {reset();}
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(nullptr_t) _NOEXCEPT
     {
         reset();
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY typename add_lvalue_reference<_Tp>::type operator*() const
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    typename add_lvalue_reference<_Tp>::type operator*() const
         {return *__ptr_.first();}
-    _LIBCPP_INLINE_VISIBILITY pointer operator->() const _NOEXCEPT {return __ptr_.first();}
-    _LIBCPP_INLINE_VISIBILITY pointer get() const _NOEXCEPT {return __ptr_.first();}
-    _LIBCPP_INLINE_VISIBILITY       _Dp_reference get_deleter() _NOEXCEPT
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    pointer operator->() const _NOEXCEPT {return __ptr_.first();}
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    pointer get() const _NOEXCEPT {return __ptr_.first();}
+    _LIBCPP_INLINE_VISIBILITY _Dp_reference get_deleter() _NOEXCEPT
         {return __ptr_.second();}
     _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT
         {return __ptr_.second();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
         _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT
         {return __ptr_.first() != nullptr;}
 
+#ifndef _LIBCPP_DISABLE_NO_DISCARD_UNIQUE_PTR_RELEASE
+    _LIBCPP_NO_DISCARD
+#endif
     _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT
     {
         pointer __t = __ptr_.first();
         __ptr_.first() = pointer();
         return __t;
     }
 
     _LIBCPP_INLINE_VISIBILITY void reset(pointer __p = pointer()) _NOEXCEPT

     _LIBCPP_INLINE_VISIBILITY ~unique_ptr() {reset();}
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(nullptr_t) _NOEXCEPT
     {
         reset();
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY typename add_lvalue_reference<_Tp>::type operator[](size_t __i) const
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    typename add_lvalue_reference<_Tp>::type operator[](size_t __i) const
         {return __ptr_.first()[__i];}
-    _LIBCPP_INLINE_VISIBILITY pointer get() const _NOEXCEPT {return __ptr_.first();}
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    pointer get() const _NOEXCEPT {return __ptr_.first();}
     _LIBCPP_INLINE_VISIBILITY       _Dp_reference get_deleter() _NOEXCEPT
         {return __ptr_.second();}
     _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT
         {return __ptr_.second();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
         _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT
         {return __ptr_.first() != nullptr;}
 
+#ifndef _LIBCPP_DISABLE_NO_DISCARD_UNIQUE_PTR_RELEASE
+    _LIBCPP_NO_DISCARD
+#endif
     _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT
     {
         pointer __t = __ptr_.first();
         __ptr_.first() = pointer();
         return __t;
     }
 
     template <class _Pp>

             :  __data_(__a, _Tp(__a0, __a1, __a2)) {}
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 private:
     virtual void __on_zero_shared() _NOEXCEPT;
     virtual void __on_zero_shared_weak() _NOEXCEPT;
 public:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_INTERNAL _LIBCPP_INLINE_VISIBILITY
     _Tp* get() _NOEXCEPT {return &__data_.second();}
 };
 
 template <class _Tp, class _Alloc>
 void
 __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     __data_.second().~_Tp();

         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             void
         >::type
         _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p, _Dp __d, _Alloc __a);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     element_type* get() const _NOEXCEPT {return __ptr_;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT
         {return *__ptr_;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     element_type* operator->() const _NOEXCEPT {return __ptr_;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool unique() const _NOEXCEPT {return use_count() == 1;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != 0;}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(shared_ptr<_Up> const& __p) const
         {return __cntrl_ < __p.__cntrl_;}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(weak_ptr<_Up> const& __p) const

 template<class _Yp>
 shared_ptr<_Tp>::shared_ptr(_Yp* __p,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
     : __ptr_(__p)
 {
     unique_ptr<_Yp> __hold(__p);
     typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
     __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), allocator<_Yp>());
-    __hold.release();
+    (void)__hold.release();
     __enable_weak_this(__p, __p);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp>
 shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
     : __ptr_(__p)

         __cntrl_ = nullptr;
     else
 #endif
     {
         typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), allocator<_Yp>());
         __enable_weak_this(__r.get(), __r.get());
     }
-    __r.release();
+    (void)__r.release();
 }
 
 template<class _Tp>
 template <class _Yp, class _Dp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
 #else
 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,

         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(weak_ptr& __r) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void reset() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT
         {return __cntrl_ ? __cntrl_->use_count() : 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_SMART_PTR_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool expired() const _NOEXCEPT
         {return __cntrl_ == 0 || __cntrl_->use_count() == 0;}
     shared_ptr<_Tp> lock() const _NOEXCEPT;
     template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const shared_ptr<_Up>& __r) const
         {return __cntrl_ < __r.__cntrl_;}
     template<class _Up>

include/mutex

public:
      ~recursive_mutex();
 
 private:
     recursive_mutex(const recursive_mutex&); // = delete;
     recursive_mutex& operator=(const recursive_mutex&); // = delete;
 
 public:
     void lock();
-    bool try_lock() _NOEXCEPT;
+    _LIBCPP_NO_DISCARD_TRY_LOCK bool try_lock() _NOEXCEPT;
     void unlock()  _NOEXCEPT;
 
     typedef __libcpp_mutex_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() {return &__m_;}
 };
 
 class _LIBCPP_TYPE_VIS timed_mutex
 {
     mutex              __m_;
     condition_variable __cv_;
     bool               __locked_;
 public:
      timed_mutex();
      ~timed_mutex();
 
 private:
     timed_mutex(const timed_mutex&); // = delete;
     timed_mutex& operator=(const timed_mutex&); // = delete;
 
 public:
     void lock();
-    bool try_lock() _NOEXCEPT;
+    _LIBCPP_NO_DISCARD_TRY_LOCK bool try_lock() _NOEXCEPT;
     template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_NO_DISCARD_TRY_LOCK _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
+        _LIBCPP_NO_DISCARD_TRY_LOCK
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
 bool
 timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
public:
      ~recursive_timed_mutex();
 
 private:
     recursive_timed_mutex(const recursive_timed_mutex&); // = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&); // = delete;
 
 public:
     void lock();
-    bool try_lock() _NOEXCEPT;
+    _LIBCPP_NO_DISCARD_TRY_LOCK bool try_lock() _NOEXCEPT;
     template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_NO_DISCARD_TRY_LOCK _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
+        _LIBCPP_NO_DISCARD_TRY_LOCK
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
 bool
 recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {

include/regex

 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
                                       _ForwardIterator __last)
 {
     {
         unique_ptr<__node> __h(new __end_state<_CharT>);
         __start_.reset(new __empty_state<_CharT>(__h.get()));
-        __h.release();
+        (void)__h.release();
         __end_ = __start_.get();
     }
     switch (__flags_ & 0x1F0)
     {
     case ECMAScript:
         __first = __parse_ecma_exp(__first, __last);
         break;
     case basic:

         bool __greedy)
 {
     unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
     __end_->first() = nullptr;
     unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_,
                 __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy,
                 __min, __max));
     __s->first() = nullptr;
-    __e1.release();
+    (void)__e1.release();
     __end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
     __end_ = __e2->second();
     __s->first() = __e2.release();
     ++__loop_count_;
 }
 
 template <class _CharT, class _Traits>
 void

include/set

#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     const_iterator cbegin()  const _NOEXCEPT {return begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend() const _NOEXCEPT {return end();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
 
     // modifiers:
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> emplace(_Args&&... __args)
             {return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     const_iterator cbegin()  const _NOEXCEPT {return begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend() const _NOEXCEPT {return end();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
 
     // modifiers:
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace(_Args&&... __args)
             {return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}

include/shared_mutex

struct _LIBCPP_TYPE_VIS __shared_mutex_base
     __shared_mutex_base();
     _LIBCPP_INLINE_VISIBILITY ~__shared_mutex_base() = default;
 
     __shared_mutex_base(const __shared_mutex_base&) = delete;
     __shared_mutex_base& operator=(const __shared_mutex_base&) = delete;
 
     // Exclusive ownership
     void lock(); // blocking
-    bool try_lock();
+    _LIBCPP_NO_DISCARD_INTERNAL bool try_lock();
     void unlock();
 
     // Shared ownership
     void lock_shared(); // blocking
-    bool try_lock_shared();
+    _LIBCPP_NO_DISCARD_INTERNAL bool try_lock_shared();
     void unlock_shared();
 
 //     typedef implementation-defined native_handle_type; // See 30.2.3
 //     native_handle_type native_handle(); // See 30.2.3
 };
 
 
 #if _LIBCPP_STD_VER > 14
 class _LIBCPP_TYPE_VIS shared_mutex
 {
   __shared_mutex_base __base;
 public:
     shared_mutex() : __base() {}
     _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default;
 
     shared_mutex(const shared_mutex&) = delete;
     shared_mutex& operator=(const shared_mutex&) = delete;
 
     // Exclusive ownership
     _LIBCPP_INLINE_VISIBILITY void lock()     { return __base.lock(); }
-    _LIBCPP_INLINE_VISIBILITY bool try_lock() { return __base.try_lock(); }
+    _LIBCPP_NO_DISCARD_TRY_LOCK _LIBCPP_INLINE_VISIBILITY
+    bool try_lock() { return __base.try_lock(); }
     _LIBCPP_INLINE_VISIBILITY void unlock()   { return __base.unlock(); }
 
     // Shared ownership
     _LIBCPP_INLINE_VISIBILITY void lock_shared()     { return __base.lock_shared(); }
-    _LIBCPP_INLINE_VISIBILITY bool try_lock_shared() { return __base.try_lock_shared(); }
+    _LIBCPP_NO_DISCARD_TRY_LOCK _LIBCPP_INLINE_VISIBILITY
+    bool try_lock_shared() { return __base.try_lock_shared(); }
     _LIBCPP_INLINE_VISIBILITY void unlock_shared()   { return __base.unlock_shared(); }
 
 //     typedef __shared_mutex_base::native_handle_type native_handle_type;
 //     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() { return __base::unlock_shared(); }
 };
 #endif
 
 
 class _LIBCPP_TYPE_VIS shared_timed_mutex
 {
   __shared_mutex_base __base;
 public:
     shared_timed_mutex();
     _LIBCPP_INLINE_VISIBILITY ~shared_timed_mutex() = default;
 
     shared_timed_mutex(const shared_timed_mutex&) = delete;
     shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
 
     // Exclusive ownership
     void lock();
-    bool try_lock();
+    _LIBCPP_NO_DISCARD_TRY_LOCK bool try_lock();
     template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_NO_DISCARD_TRY_LOCK _LIBCPP_INLINE_VISIBILITY
         bool
         try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
         {
             return try_lock_until(chrono::steady_clock::now() + __rel_time);
         }
     template <class _Clock, class _Duration>
-        bool
+        _LIBCPP_NO_DISCARD_TRY_LOCK bool
         try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
     void unlock();
 
     // Shared ownership
     void lock_shared();
-    bool try_lock_shared();
+    _LIBCPP_NO_DISCARD_TRY_LOCK bool try_lock_shared();
     template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_NO_DISCARD_TRY_LOCK _LIBCPP_INLINE_VISIBILITY
         bool
         try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
         {
             return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
         }
     template <class _Clock, class _Duration>
-        bool
+        _LIBCPP_NO_DISCARD_TRY_LOCK bool
         try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
     void unlock_shared();
 };
 
 template <class _Clock, class _Duration>
 bool
 shared_timed_mutex::try_lock_until(
                         const chrono::time_point<_Clock, _Duration>& __abs_time)
shared_lock& operator=(shared_lock&& __u) _NOEXCEPT
         __m_ = __u.__m_;
         __owns_ = __u.__owns_;
         __u.__m_ = nullptr;
         __u.__owns_ = false;
         return *this;
     }
 
     void lock();
-    bool try_lock();
+    _LIBCPP_NO_DISCARD_TRY_LOCK bool try_lock();
     template <class Rep, class Period>
+        _LIBCPP_NO_DISCARD_TRY_LOCK
         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
+        _LIBCPP_NO_DISCARD_TRY_LOCK
         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock();
 
     // Setters
     _LIBCPP_INLINE_VISIBILITY
     void swap(shared_lock& __u) _NOEXCEPT
     {
         _VSTD::swap(__m_, __u.__m_);

include/string

const_iterator cend() const _NOEXCEPT
         {return end();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return rbegin();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT
         {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    size_type size() const _NOEXCEPT
         {return __is_long() ? __get_long_size() : __get_short_size();}
-    _LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();}
-    _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    size_type length() const _NOEXCEPT {return size();}
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    size_type max_size() const _NOEXCEPT;
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    size_type capacity() const _NOEXCEPT
         {return (__is_long() ? __get_long_cap()
                              : static_cast<size_type>(__min_cap)) - 1;}
 
     void resize(size_type __n, value_type __c);
     _LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
 
     void reserve(size_type res_arg = 0);
     _LIBCPP_INLINE_VISIBILITY
     void shrink_to_fit() _NOEXCEPT {reserve();}
     _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT {return size() == 0;}
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+    bool empty() const _NOEXCEPT {return size() == 0;}
 
     _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __pos)       _NOEXCEPT;
 
     const_reference at(size_type __n) const;
     reference       at(size_type __n);
 
     _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);}

include/string_view

// #endif
 
   _LIBCPP_INLINE_VISIBILITY
   const_reverse_iterator crbegin()  const _NOEXCEPT { return const_reverse_iterator(cend()); }
 
   _LIBCPP_INLINE_VISIBILITY
   const_reverse_iterator crend()    const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
 
   // [string.view.capacity], capacity
-  _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
   size_type size()     const _NOEXCEPT { return __size; }
 
-  _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
   size_type length()   const _NOEXCEPT { return __size; }
 
-  _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_CONSTEXPR _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
   size_type max_size() const _NOEXCEPT { return numeric_limits<size_type>::max(); }
 
-  _LIBCPP_CONSTEXPR bool _LIBCPP_INLINE_VISIBILITY
-  empty()         const _NOEXCEPT { return __size == 0; }
+  _LIBCPP_CONSTEXPR _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
+  bool empty()         const _NOEXCEPT { return __size == 0; }
 
   // [string.view.access], element access
   _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
   const_reference operator[](size_type __pos) const _NOEXCEPT { return __data[__pos]; }
 
   _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
   const_reference at(size_type __pos) const
   {

include/thread

thread::thread(_Fp&& __f, _Args&&... __args)
     _TSPtr __tsp(new __thread_struct);
     typedef tuple<_TSPtr, typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
     _VSTD::unique_ptr<_Gp> __p(
             new _Gp(std::move(__tsp),
                     __decay_copy(_VSTD::forward<_Fp>(__f)),
                     __decay_copy(_VSTD::forward<_Args>(__args))...));
     int __ec = __libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get());
     if (__ec == 0)
-        __p.release();
+        (void)__p.release();
     else
         __throw_system_error(__ec, "thread constructor failed");
 }
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Fp>
 struct __thread_invoke_pair {

 thread::thread(_Fp __f)
 {
 
     typedef __thread_invoke_pair<_Fp> _InvokePair;
     typedef std::unique_ptr<_InvokePair> _PairPtr;
     _PairPtr __pp(new _InvokePair(__f));
     int __ec = __libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get());
     if (__ec == 0)
-        __pp.release();
+        (void)__pp.release();
     else
         __throw_system_error(__ec, "thread constructor failed");
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 

include/unordered_map

#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     unordered_map& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __table_.max_size();}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT        {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
     iterator       end() _NOEXCEPT          {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __table_.max_size();}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT        {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
     iterator       end() _NOEXCEPT          {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const _NOEXCEPT {return __table_.begin();}

include/unordered_set

#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     unordered_set& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __table_.max_size();}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT        {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
     iterator       end() _NOEXCEPT          {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const _NOEXCEPT {return __table_.begin();}

 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     unordered_multiset& operator=(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __table_.max_size();}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT        {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
     iterator       end() _NOEXCEPT          {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const _NOEXCEPT {return __table_.begin();}

include/vector

const_iterator         cend()    const _NOEXCEPT
         {return end();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return rbegin();}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend()   const _NOEXCEPT
         {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT
         {return static_cast<size_type>(this->__end_ - this->__begin_);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type capacity() const _NOEXCEPT
         {return __base::capacity();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
         {return this->__begin_ == this->__end_;}
-    size_type max_size() const _NOEXCEPT;
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS size_type max_size() const _NOEXCEPT;
     void reserve(size_type __n);
     void shrink_to_fit() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n);
     _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const;
     reference       at(size_type __n);
     const_reference at(size_type __n) const;
 
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     void assign(initializer_list<value_type> __il)
         {assign(__il.begin(), __il.end());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(this->__alloc());}
 
-    size_type max_size() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS size_type max_size() const _NOEXCEPT;
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type capacity() const _NOEXCEPT
         {return __internal_cap_to_external(__cap());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT
         {return __size_;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NO_DISCARD_CONTAINER_OBSERVERS _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
         {return __size_ == 0;}
     void reserve(size_type __n);
     void shrink_to_fit() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     iterator begin() _NOEXCEPT
         {return __make_iter(0);}

test/libcxx/containers/no-discard-disable.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-diagnostics
+
+// test the generated [[no_discard]] warnings
+
+#define _LIBCPP_DISABLE_NO_DISCARD_CONTAINER_OBSERVERS
+#include <vector>
+#include <deque>
+#include <list>
+#include <forward_list>
+#include <set>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <string>
+#include <string_view>
+
+// Note: -Wunused-result is not emitted from within function templates so
+// we instead use a macro to avoid duplication.
+#define TEST_WARNING4(...) \
+  do { __VA_ARGS__ C; C.empty(); C.size(); C.capacity(); C.max_size(); } while (false)
+
+#define TEST_WARNING3(...) \
+  do { __VA_ARGS__ C; C.empty(); C.size(); C.max_size(); } while (false)
+
+int main() {
+  // expected-no-diagnostics
+  // std::vector
+  {
+    TEST_WARNING4(std::vector<int>);
+    TEST_WARNING4(std::vector<bool>);
+  }
+  // std::string
+  {
+    TEST_WARNING4(std::string);
+    std::string s;
+    s.length();
+  }
+  {
+    TEST_WARNING3(std::string_view);
+    std::string_view s;
+    s.length();
+  }
+  {
+    TEST_WARNING3(std::deque<int>);
+  }
+  {
+    TEST_WARNING3(std::list<int>);
+  }
+  {
+    std::forward_list<int> C;
+    C.empty();
+    C.max_size();
+  }
+  {
+    TEST_WARNING3(std::set<int>);
+    TEST_WARNING3(std::multiset<int>);
+  }
+  {
+    TEST_WARNING3(std::map<int, int>);
+    TEST_WARNING3(std::multimap<int, int>);
+  }
+  {
+    TEST_WARNING3(std::unordered_set<int>);
+    TEST_WARNING3(std::unordered_multiset<int>);
+  }
+  {
+    TEST_WARNING3(std::unordered_map<int, int>);
+    TEST_WARNING3(std::unordered_multimap<int, int>);
+  }
+}

test/libcxx/containers/no-discard.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-diagnostics
+
+// test the generated [[no_discard]] warnings
+
+#include <vector>
+#include <deque>
+#include <list>
+#include <forward_list>
+#include <set>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <string>
+#include <string_view>
+
+// Note: -Wunused-result is not emitted from within function templates so
+// we instead use a macro to avoid duplication.
+#define TEST_WARNING4(...) \
+  do { __VA_ARGS__ C; C.empty(); C.size(); C.capacity(); C.max_size(); } while (false)
+
+#define TEST_WARNING3(...) \
+  do { __VA_ARGS__ C; C.empty(); C.size(); C.max_size(); } while (false)
+
+int main() {
+  // std::vector
+  {
+    TEST_WARNING4(std::vector<int>); // expected-warning 4 {{ignoring return value}}
+    TEST_WARNING4(std::vector<bool>); // expected-warning 4 {{ignoring return value}}
+  }
+  // std::string
+  {
+    TEST_WARNING4(std::string); // expected-warning 4 {{ignoring return value}}
+    std::string s;
+    s.length(); // expected-warning {{ignoring return value}}
+  }
+  {
+    TEST_WARNING3(std::string_view); // expected-warning 3 {{ignoring return value}}
+    std::string_view s;
+    s.length(); // expected-warning {{ignoring return value}}
+  }
+  {
+    TEST_WARNING3(std::deque<int>); // expected-warning 3 {{ignoring return value}}
+  }
+  {
+    TEST_WARNING3(std::list<int>); // expected-warning 3 {{ignoring return value}}
+  }
+  {
+    std::forward_list<int> C;
+    C.empty(); // expected-warning {{ignoring return value}}
+    C.max_size(); // expected-warning {{ignoring return value}}
+  }
+  {
+    TEST_WARNING3(std::set<int>); // expected-warning 3 {{ignoring return value}}
+    TEST_WARNING3(std::multiset<int>); // expected-warning 3 {{ignoring return value}}
+  }
+  {
+    TEST_WARNING3(std::map<int, int>); // expected-warning 3 {{ignoring return value}}
+    TEST_WARNING3(std::multimap<int, int>); // expected-warning 3 {{ignoring return value}}
+  }
+  {
+    TEST_WARNING3(std::unordered_set<int>); // expected-warning 3 {{ignoring return value}}
+    TEST_WARNING3(std::unordered_multiset<int>); // expected-warning 3 {{ignoring return value}}
+  }
+  {
+    TEST_WARNING3(std::unordered_map<int, int>); // expected-warning 3 {{ignoring return value}}
+    TEST_WARNING3(std::unordered_multimap<int, int>); // expected-warning 3 {{ignoring return value}}
+  }
+}

test/libcxx/test/config.py

def configure_use_clang_verify(self):
         self.use_clang_verify = self.get_lit_bool('use_clang_verify')
         if self.use_clang_verify is None:
             # NOTE: We do not test for the -verify flag directly because
             #   -verify will always exit with non-zero on an empty file.
             self.use_clang_verify = self.cxx.hasCompileFlag(
                 ['-Xclang', '-verify-ignore-unexpected'])
             self.lit_config.note(
                 "inferred use_clang_verify as: %r" % self.use_clang_verify)
+        if self.use_clang_verify:
+            self.config.available_features.add('verify-diagnostics')
 
     def configure_use_thread_safety(self):
         '''If set, run clang with -verify on failing tests.'''
         has_thread_safety = self.cxx.hasCompileFlag('-Werror=thread-safety')
         if has_thread_safety:
             self.cxx.compile_flags += ['-Werror=thread-safety']
             self.config.available_features.add('thread-safety')
             self.lit_config.note("enabling thread-safety annotations")

test/libcxx/thread/thread.mutex/try_lock_no_discard.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: libcpp-has-no-threads
+// REQUIRES: verify-diagnostics
+
+// test the generated [[no_discard]] warnings
+
+#include <mutex>
+#include <shared_mutex>
+
+#include "test_macros.h"
+
+int main() {
+  {
+    std::mutex m;
+    m.try_lock(); // expected-warning {{ignoring return value}}
+    m.unlock();
+  }
+  {
+    std::recursive_mutex m;
+    m.try_lock(); // expected-warning {{ignoring return value}}
+    m.unlock();
+  }
+  {
+    std::timed_mutex m;
+    m.try_lock(); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_for(std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+  }
+  {
+    std::recursive_timed_mutex m;
+    m.try_lock(); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_for(std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+  }
+  {
+    std::mutex m;
+    std::unique_lock<std::mutex> lk(m);
+    lk.unlock();
+    lk.try_lock(); // expected-warning {{ignoring return value}}
+  }
+  {
+    std::timed_mutex m;
+    std::unique_lock<std::timed_mutex> lk(m);
+    lk.unlock();
+    lk.try_lock(); // expected-warning {{ignoring return value}}
+    lk.unlock();
+    lk.try_lock_for(std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    lk.unlock();
+    lk.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    lk.unlock();
+  }
+#if TEST_STD_VER > 11
+  {
+    std::shared_timed_mutex m;
+    m.try_lock(); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_for(std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_shared(); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_shared_for(std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_shared_until(std::chrono::steady_clock::now() + std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    m.unlock();
+  }
+  {
+    std::shared_timed_mutex m;
+    std::shared_lock<std::shared_timed_mutex> lk(m);
+    lk.unlock();
+    lk.try_lock(); // expected-warning {{ignoring return value}}
+    lk.unlock();
+    lk.try_lock_for(std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    lk.unlock();
+    lk.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1)); // expected-warning {{ignoring return value}}
+    lk.unlock();
+  }
+#endif
+#if TEST_STD_VER > 14
+  {
+    std::shared_mutex m;
+    m.try_lock(); // expected-warning {{ignoring return value}}
+    m.unlock();
+    m.try_lock_shared(); // expected-warning {{ignoring return value}}
+    m.unlock();
+  };
+#endif
+}

test/libcxx/thread/thread.mutex/try_lock_no_discard_disabled.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: libcpp-has-no-threads
+// REQUIRES: verify-diagnostics
+
+// test the generated [[no_discard]] warnings
+
+#define _LIBCPP_DISABLE_NO_DISCARD_TRY_LOCK
+#include <mutex>
+#include <shared_mutex>
+
+#include "test_macros.h"
+
+int main() {
+  // expected-no-diagnostics
+  {
+    std::mutex m;
+    m.try_lock();
+    m.unlock();
+  }
+  {
+    std::recursive_mutex m;
+    m.try_lock();
+    m.unlock();
+  }
+  {
+    std::timed_mutex m;
+    m.try_lock();
+    m.unlock();
+    m.try_lock_for(std::chrono::seconds(1));
+    m.unlock();
+    m.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1));
+    m.unlock();
+  }
+  {
+    std::recursive_timed_mutex m;
+    m.try_lock();
+    m.unlock();
+    m.try_lock_for(std::chrono::seconds(1));
+    m.unlock();
+    m.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1));
+    m.unlock();
+  }
+  {
+    std::mutex m;
+    std::unique_lock<std::mutex> lk(m);
+    lk.unlock();
+    lk.try_lock();
+  }
+  {
+    std::timed_mutex m;
+    std::unique_lock<std::timed_mutex> lk(m);
+    lk.unlock();
+    lk.try_lock();
+    lk.unlock();
+    lk.try_lock_for(std::chrono::seconds(1));
+    lk.unlock();
+    lk.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1));
+    lk.unlock();
+  }
+#if TEST_STD_VER > 11
+  {
+    std::shared_timed_mutex m;
+    m.try_lock();
+    m.unlock();
+    m.try_lock_for(std::chrono::seconds(1));
+    m.unlock();
+    m.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1));
+    m.unlock();
+    m.try_lock_shared();
+    m.unlock();
+    m.try_lock_shared_for(std::chrono::seconds(1));
+    m.unlock();
+    m.try_lock_shared_until(std::chrono::steady_clock::now() + std::chrono::seconds(1));
+    m.unlock();
+  }
+  {
+    std::shared_timed_mutex m;
+    std::shared_lock<std::shared_timed_mutex> lk(m);
+    lk.unlock();
+    lk.try_lock();
+    lk.unlock();
+    lk.try_lock_for(std::chrono::seconds(1));
+    lk.unlock();
+    lk.try_lock_until(std::chrono::steady_clock::now() + std::chrono::seconds(1));
+    lk.unlock();
+  }
+#endif
+#if TEST_STD_VER > 14
+  {
+    std::shared_mutex m;
+    m.try_lock();
+    m.unlock();
+    m.try_lock_shared();
+    m.unlock();
+  };
+#endif
+}

test/libcxx/utilities/memory/disable_no_discard_smart_ptr_observers.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-diagnostics
+
+// <memory>
+
+// test the generated [[no_discard]] warnings for shared_ptr,
+// weak_ptr, and unique_ptr's observers.
+
+#define _LIBCPP_DISABLE_NO_DISCARD_SMART_PTR_OBSERVERS
+#include <memory>
+#include <cassert>
+
+int main()
+{
+    // expected-no-diagnostics
+    // shared_ptr
+    {
+        std::shared_ptr<int> p;
+        p.get();
+        *p;
+        p.operator->();
+        p.operator bool();
+        p.use_count();
+        p.unique();
+    }
+    // weak_ptr
+    {
+        std::weak_ptr<int> p;
+        p.use_count();
+        p.expired();
+    }
+    // unique_ptr single
+    {
+        std::unique_ptr<int> p;
+        p.get();
+        *p;
+        p.operator->();
+        p.operator bool();
+    }
+    // unique_ptr array
+    {
+        std::unique_ptr<int[]> p;
+        p.get();
+        p[0];
+        p.operator bool();
+    }
+}

test/libcxx/utilities/memory/no_discard_smart_ptr_observers.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-diagnostics
+
+// <memory>
+
+// test the generated [[no_discard]] warnings for shared_ptr,
+// weak_ptr, and unique_ptr's observers.
+
+#include <memory>
+#include <cassert>
+
+int main()
+{
+    // shared_ptr
+    {
+        std::shared_ptr<int> p;
+        p.get(); // expected-warning {{ignoring return value}}
+        *p; // expected-warning {{ignoring return value}}
+        p.operator->(); // expected-warning {{ignoring return value}}
+        p.operator bool(); // expected-warning {{ignoring return value}}
+        p.use_count(); // expected-warning {{ignoring return value}}
+        p.unique(); // expected-warning {{ignoring return value}}
+    }
+    // weak_ptr
+    {
+        std::weak_ptr<int> p;
+        p.use_count(); // expected-warning {{ignoring return value}}
+        p.expired(); // expected-warning {{ignoring return value}}
+    }
+    // unique_ptr single
+    {
+        std::unique_ptr<int> p;
+        p.get(); // expected-warning {{ignoring return value}}
+        *p; // expected-warning {{ignoring return value}}
+        p.operator->(); // expected-warning {{ignoring return value}}
+        p.operator bool(); // expected-warning {{ignoring return value}}
+    }
+    // unique_ptr array
+    {
+        std::unique_ptr<int[]> p;
+        p.get(); // expected-warning {{ignoring return value}}
+        p[0]; // expected-warning {{ignoring return value}}
+        p.operator bool(); // expected-warning {{ignoring return value}}
+    }
+}

test/libcxx/utilities/memory/unique.ptr/disable_no_discard_release.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-diagnostics
+
+// <memory>
+
+// unique_ptr
+
+// test [[no_discard]] warnings for release
+
+#define _LIBCPP_DISABLE_NO_DISCARD_UNIQUE_PTR_RELEASE
+#include <memory>
+#include <cassert>
+
+int main()
+{
+    // expected-no-diagnostics
+    {
+        std::unique_ptr<int> p;
+        p.release();
+    }
+    {
+        std::unique_ptr<int[]> p;
+        p.release();
+    }
+}

test/libcxx/utilities/memory/unique.ptr/no_discard_release.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-diagnostics
+
+// <memory>
+
+// unique_ptr
+
+// test [[no_discard]] warnings for release
+
+#include <memory>
+#include <cassert>
+
+int main()
+{
+    {
+        std::unique_ptr<int> p;
+        p.release(); // expected-warning {{ignoring return value}}
+    }
+    {
+        std::unique_ptr<int[]> p;
+        p.release(); // expected-warning {{ignoring return value}}
+    }
+}

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
     assert(try_lock_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        (void)lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock() == false);
     assert(try_lock_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        (void)lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
     assert(try_lock_for_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        (void)lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_for(ms(5)) == false);
     assert(try_lock_for_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        (void)lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

int main()
     typedef std::chrono::steady_clock Clock;
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_until(Clock::now()) == true);
     assert(try_lock_until_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        (void)lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_until(Clock::now()) == false);
     assert(try_lock_until_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        (void)lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp

 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
     assert(try_lock_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        (void)lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock() == false);
     assert(try_lock_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        (void)lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp

 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
     assert(try_lock_for_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        (void)lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_for(ms(5)) == false);
     assert(try_lock_for_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        (void)lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp

int main()
     typedef std::chrono::steady_clock Clock;
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_until(Clock::now()) == true);
     assert(try_lock_until_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        (void)lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_until(Clock::now()) == false);
     assert(try_lock_until_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        (void)lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }