[libc++] Enable `explicit` conversion operators, even in C++03 mode.

[• Quuxplusone]

Summary

This is a "pivot" of the third part of D104310: instead of doing all of iostreams at once, let's do everyone's explicit conversion operators at once!

C++03 didn't support `explicit` conversion operators;
but Clang's C++03 mode does, as an extension, so we can use it.
This lets us make the conversion explicit in `std::function` (even in '03),
and remove some silly metaprogramming in `std::basic_ios`.

Drive-by improvements to the tests for these operators, in addition
to making sure all these tests also run in `c++03` mode.

[ldionne]

So the logic here is that we're not adding // UNSUPPORTED: c++03 to those tests even though they technically require C++11 (since we're testing stuff like std::shared_ptr, which was added in C++11), because libc++ implements those types as an extension?

I think it would be more logical to use // UNSUPPORTED: c++03 && !libc++. That way, other standard libraries that do not support those types in C++03 mode will not fail the test suite. WDYT?

Other than that, I'm fine with the changes and I like that we're removing workarounds for missing C++03 language features.

[ldionne]

I just read https://reviews.llvm.org/D104172#2830696.

I think we need to figure out what to do with C++03 in the test suite (you accurately explained the state of things in https://reviews.llvm.org/D104172#2830696, but that state of things is not what it should be IMO). However, this patch is orthogonal to figuring that out, so I'm fine with it. Thanks a lot for the clean up!

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp

13

Thanks for that.

[efriedma]

This apparently broke compiling the following testcase, reduced from SPEC2006, in c++98 mode:

#include <istream>
bool a(std::istream a) {
    return a.getline(0,0) == 0;
}

libcxx/include/__config

 #endif
 
 #ifdef __GNUC__
 #  define _LIBCPP_NOALIAS __attribute__((__malloc__))
 #else
 #  define _LIBCPP_NOALIAS
 #endif
 
-#if __has_feature(cxx_explicit_conversions) || defined(__IBMCPP__) || \
-    (!defined(_LIBCPP_CXX03_LANG) && defined(__GNUC__)) // All supported GCC versions
-#  define _LIBCPP_EXPLICIT explicit
-#else
-#  define _LIBCPP_EXPLICIT
-#endif
-
 #if __has_attribute(using_if_exists)
 # define _LIBCPP_USING_IF_EXISTS __attribute__((using_if_exists))
 #else
 # define _LIBCPP_USING_IF_EXISTS
 #endif
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 #  define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx

libcxx/include/__functional_03

public:
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
     template<class _Fp, class _Alloc>
       _LIBCPP_INLINE_VISIBILITY
       void assign(_Fp __f, const _Alloc& __a)
         {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
-    _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;}
+    _LIBCPP_INLINE_VISIBILITY explicit operator bool() const {return __f_;}
 
 private:
     // deleted overloads close possible hole in the type system
     template<class _R2>
       bool operator==(const function<_R2()>&) const;// = delete;
     template<class _R2>
       bool operator!=(const function<_R2()>&) const;// = delete;
 public:
public:
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
     template<class _Fp, class _Alloc>
       _LIBCPP_INLINE_VISIBILITY
       void assign(_Fp __f, const _Alloc& __a)
         {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
-    _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;}
+    _LIBCPP_INLINE_VISIBILITY explicit operator bool() const {return __f_;}
 
 private:
     // deleted overloads close possible hole in the type system
     template<class _R2, class _B0>
       bool operator==(const function<_R2(_B0)>&) const;// = delete;
     template<class _R2, class _B0>
       bool operator!=(const function<_R2(_B0)>&) const;// = delete;
 public:
public:
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
     template<class _Fp, class _Alloc>
       _LIBCPP_INLINE_VISIBILITY
       void assign(_Fp __f, const _Alloc& __a)
         {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
-    operator bool() const {return __f_;}
+    _LIBCPP_INLINE_VISIBILITY explicit operator bool() const {return __f_;}
 
 private:
     // deleted overloads close possible hole in the type system
     template<class _R2, class _B0, class _B1>
       bool operator==(const function<_R2(_B0, _B1)>&) const;// = delete;
     template<class _R2, class _B0, class _B1>
       bool operator!=(const function<_R2(_B0, _B1)>&) const;// = delete;
 public:
public:
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
     template<class _Fp, class _Alloc>
       _LIBCPP_INLINE_VISIBILITY
       void assign(_Fp __f, const _Alloc& __a)
         {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
-    _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;}
+    _LIBCPP_INLINE_VISIBILITY explicit operator bool() const {return __f_;}
 
 private:
     // deleted overloads close possible hole in the type system
     template<class _R2, class _B0, class _B1, class _B2>
       bool operator==(const function<_R2(_B0, _B1, _B2)>&) const;// = delete;
     template<class _R2, class _B0, class _B1, class _B2>
       bool operator!=(const function<_R2(_B0, _B1, _B2)>&) const;// = delete;
 public:

libcxx/include/__memory/shared_ptr.h

element_type* operator->() const _NOEXCEPT
                       "std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
         return __ptr_;
     }
     _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;}
     _LIBCPP_INLINE_VISIBILITY
     bool unique() const _NOEXCEPT {return use_count() == 1;}
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != nullptr;}
+    explicit operator bool() const _NOEXCEPT {return get() != nullptr;}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT
         {return __cntrl_ < __p.__cntrl_;}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT
         {return __cntrl_ < __p.__cntrl_;}

libcxx/include/__memory/unique_ptr.h

#endif
   deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
   _LIBCPP_INLINE_VISIBILITY
   const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
   _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
+  explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
   _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
+  explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;

libcxx/include/__mutex_base

mutex_type* release() _NOEXCEPT
         __m_ = nullptr;
         __owns_ = false;
         return __m;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool owns_lock() const _NOEXCEPT {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT
-        operator bool () const _NOEXCEPT {return __owns_;}
+    explicit operator bool () const _NOEXCEPT {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* mutex() const _NOEXCEPT {return __m_;}
 };
 
 template <class _Mutex>
 void
 unique_lock<_Mutex>::lock()
 {

libcxx/include/exception

 public:
     _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
     _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
 
     exception_ptr(const exception_ptr&) _NOEXCEPT;
     exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
     ~exception_ptr() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY explicit operator bool() const _NOEXCEPT
     {return __ptr_ != nullptr;}
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
         {return __x.__ptr_ == __y.__ptr_;}
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT

 #endif
 public:
     exception_ptr() _NOEXCEPT;
     exception_ptr(nullptr_t) _NOEXCEPT;
     exception_ptr(const exception_ptr& __other) _NOEXCEPT;
     exception_ptr& operator=(const exception_ptr& __other) _NOEXCEPT;
     exception_ptr& operator=(nullptr_t) _NOEXCEPT;
     ~exception_ptr() _NOEXCEPT;
-    _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT;
+    explicit operator bool() const _NOEXCEPT;
 };
 
 _LIBCPP_FUNC_VIS
 bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT;
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
     {return !(__x == __y);}

libcxx/include/functional

             __f.__f_ = __f_;
             __f_ = __as_base(&__buf_);
         }
         else
             _VSTD::swap(__f_, __f.__f_);
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { return __f_ != nullptr; }
+    explicit operator bool() const _NOEXCEPT { return __f_ != nullptr; }
 
 #ifndef _LIBCPP_NO_RTTI
     _LIBCPP_INLINE_VISIBILITY
     const std::type_info& target_type() const _NOEXCEPT
     {
         if (__f_ == nullptr)
             return typeid(void);
         return __f_->target_type();

     template<class _Fp, class _Alloc>
       _LIBCPP_INLINE_VISIBILITY
       void assign(_Fp&& __f, const _Alloc& __a)
         {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
 #endif
 
     // function capacity:
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
+    explicit operator bool() const _NOEXCEPT {
       return static_cast<bool>(__f_);
     }
 
     // deleted overloads close possible hole in the type system
     template<class _R2, class... _ArgTypes2>
       bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
     template<class _R2, class... _ArgTypes2>
       bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;

libcxx/include/ios

 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::exceptions(iostate __iostate)
 {
     __exceptions_ = __iostate;
     clear(__rdstate_);
 }
 
-#if defined(_LIBCPP_CXX03_LANG)
-struct _LIBCPP_TYPE_VIS __cxx03_bool {
-  typedef void (__cxx03_bool::*__bool_type)();
-  void __true_value() {}
-};
-#endif
-
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_ios
     : public ios_base
 {
 public:
     // types:
     typedef _CharT char_type;
     typedef _Traits traits_type;
 
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     static_assert((is_same<_CharT, typename traits_type::char_type>::value),
                   "traits_type::char_type must be the same type as CharT");
 
-  // __true_value will generate undefined references when linking unless
-  // we give it internal linkage.
-
-#if defined(_LIBCPP_CXX03_LANG)
     _LIBCPP_INLINE_VISIBILITY
-    operator __cxx03_bool::__bool_type() const {
-        return !fail() ? &__cxx03_bool::__true_value : nullptr;
-    }
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT operator bool() const {return !fail();}
-#endif
+    explicit operator bool() const {return !fail();}
 
     _LIBCPP_INLINE_VISIBILITY bool operator!() const    {return  fail();}
     _LIBCPP_INLINE_VISIBILITY iostate rdstate() const   {return ios_base::rdstate();}
     _LIBCPP_INLINE_VISIBILITY void clear(iostate __state = goodbit) {ios_base::clear(__state);}
     _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state) {ios_base::setstate(__state);}
     _LIBCPP_INLINE_VISIBILITY bool good() const {return ios_base::good();}
     _LIBCPP_INLINE_VISIBILITY bool eof() const  {return ios_base::eof();}
     _LIBCPP_INLINE_VISIBILITY bool fail() const {return ios_base::fail();}

libcxx/include/istream

class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry
     sentry(const sentry&); // = delete;
     sentry& operator=(const sentry&); // = delete;
 
 public:
     explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
 //    ~sentry() = default;
 
     _LIBCPP_INLINE_VISIBILITY
-        _LIBCPP_EXPLICIT
-        operator bool() const {return __ok_;}
+    explicit operator bool() const {return __ok_;}
 };
 
 template <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is,
                                                bool __noskipws)
     : __ok_(false)
 {
     if (__is.good())

libcxx/include/ostream

class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry
     sentry(const sentry&); // = delete;
     sentry& operator=(const sentry&); // = delete;
 
 public:
     explicit sentry(basic_ostream<_CharT, _Traits>& __os);
     ~sentry();
 
     _LIBCPP_INLINE_VISIBILITY
-        _LIBCPP_EXPLICIT
-        operator bool() const {return __ok_;}
+    explicit operator bool() const {return __ok_;}
 };
 
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os)
     : __ok_(false),
       __os_(__os)
 {
     if (__os.good())

libcxx/include/system_error

public:
     _LIBCPP_INLINE_VISIBILITY
     int value() const _NOEXCEPT {return __val_;}
 
     _LIBCPP_INLINE_VISIBILITY
     const error_category& category() const _NOEXCEPT {return *__cat_;}
     string message() const;
 
     _LIBCPP_INLINE_VISIBILITY
-        _LIBCPP_EXPLICIT
-        operator bool() const _NOEXCEPT {return __val_ != 0;}
+    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), generic_category());
 }
public:
 
     _LIBCPP_INLINE_VISIBILITY
     error_condition default_error_condition() const _NOEXCEPT
         {return __cat_->default_error_condition(__val_);}
 
     string message() const;
 
     _LIBCPP_INLINE_VISIBILITY
-        _LIBCPP_EXPLICIT
-        operator bool() const _NOEXCEPT {return __val_ != 0;}
+    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
 make_error_code(errc __e) _NOEXCEPT
 {
     return error_code(static_cast<int>(__e), generic_category());
 }

libcxx/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.compile.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
-//
-//===----------------------------------------------------------------------===//
-
-// XFAIL: c++03
-
-// <system_error>
-
-// class error_code
-
-// explicit operator bool() const;
-
-#include <system_error>
-
-bool test_func(void)
-{
-    const std::error_code ec(0, std::generic_category());
-    return ec;   // conversion to bool is explicit; should fail.
-}
-
-int main(int, char**)
-{
-    return 0;
-}

libcxx/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <system_error>
 
 // class error_code
 
 // explicit operator bool() const;
 
 #include <system_error>
-#include <string>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+    static_assert(std::is_constructible<bool, std::error_code>::value, "");
+    static_assert(!std::is_convertible<std::error_code, bool>::value, "");
+
     {
         const std::error_code ec(6, std::generic_category());
         assert(static_cast<bool>(ec));
     }
     {
         const std::error_code ec(0, std::generic_category());
         assert(!static_cast<bool>(ec));
     }
 
   return 0;
 }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp

 {
     std::ios ios(0);
     assert(static_cast<bool>(ios) == !ios.fail());
     ios.setstate(std::ios::failbit);
     assert(static_cast<bool>(ios) == !ios.fail());
     static_assert((!std::is_convertible<std::ios, void*>::value), "");
     static_assert((!std::is_convertible<std::ios, int>::value), "");
     static_assert((!std::is_convertible<std::ios const&, int>::value), "");
-#if TEST_STD_VER >= 11
     static_assert((!std::is_convertible<std::ios, bool>::value), "");
-#endif
 
   return 0;
 }

libcxx/test/std/language.support/support.exception/propagation/exception_ptr.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <exception>
 
 // typedef unspecified exception_ptr;
 
 // exception_ptr shall satisfy the requirements of NullablePointer.
 
 #include <exception>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::exception_ptr p;
     assert(p == nullptr);
     std::exception_ptr p2 = p;
     assert(nullptr == p);
     assert(!p);
     assert(p2 == p);
     p2 = p;
     assert(p2 == p);
     assert(p2 == nullptr);
     std::exception_ptr p3 = nullptr;
     assert(p3 == nullptr);
     p3 = nullptr;
     assert(p3 == nullptr);
 
     return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.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
 // UNSUPPORTED: c++03, c++11
 
-// dylib support for shared_mutex was added in macosx10.12
-// XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.11
-// XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.10
-// XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.9
-
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // explicit operator bool() const noexcept;
 
 #include <shared_mutex>
 #include <cassert>
 
 #include "test_macros.h"
 
-std::shared_timed_mutex m;
+struct M {
+    void lock_shared() {}
+    void unlock_shared() {}
+};
 
 int main(int, char**)
 {
-    std::shared_lock<std::shared_timed_mutex> lk0;
+    static_assert(std::is_constructible<bool, std::shared_lock<M>>::value, "");
+    static_assert(!std::is_convertible<std::shared_lock<M>, bool>::value, "");
+
+    M m;
+    std::shared_lock<M> lk0;
     assert(static_cast<bool>(lk0) == false);
-    std::shared_lock<std::shared_timed_mutex> lk1(m);
+    std::shared_lock<M> lk1(m);
     assert(static_cast<bool>(lk1) == true);
     lk1.unlock();
     assert(static_cast<bool>(lk1) == false);
-    static_assert(noexcept(static_cast<bool>(lk0)), "explicit operator bool() must be noexcept");
+    ASSERT_NOEXCEPT(static_cast<bool>(lk0));
 
     return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.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
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
-// explicit operator bool() const;
+// explicit operator bool() const noexcept;
 
 #include <mutex>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 std::mutex m;
 
 int main(int, char**)
 {
+    static_assert(std::is_constructible<bool, std::unique_lock<std::mutex> >::value, "");
+    static_assert(!std::is_convertible<std::unique_lock<std::mutex>, bool>::value, "");
+
     std::unique_lock<std::mutex> lk0;
     assert(static_cast<bool>(lk0) == false);
     std::unique_lock<std::mutex> lk1(m);
     assert(static_cast<bool>(lk1) == true);
     lk1.unlock();
     assert(static_cast<bool>(lk1) == false);
+    ASSERT_NOEXCEPT(static_cast<bool>(lk0));
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp

 
 // explicit operator bool() const
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 int g(int) {return 0;}
 
 int main(int, char**)
 {
+    static_assert(std::is_constructible<bool, std::function<void()> >::value, "");
+    static_assert(!std::is_convertible<std::function<void()>, bool>::value, "");
+
     {
     std::function<int(int)> f;
     assert(!f);
     f = g;
     assert(f);
     }
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
 // explicit operator bool() const;
 
 #include <memory>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 struct A {
   int a;
   virtual ~A(){};
 };
 struct B : A {};
 
 int main(int, char**)
 {
+    static_assert(std::is_constructible<bool, std::shared_ptr<A> >::value, "");
+    static_assert(!std::is_convertible<std::shared_ptr<A>, bool>::value, "");
+
     {
       const std::shared_ptr<int> p(new int(32));
       assert(p);
     }
     {
       const std::shared_ptr<int> p;
       assert(!p);
     }