[libc++] Fix conjunction/disjunction and mark a few LWG issues as complete

[philnik]

Summary

Fixes #54803
Fixes #53133

[philnik]

• Generate files

[philnik]

• Fix order

[ldionne]

libcxx/test/std/utilities/meta/meta.logical/conjunction.compile.pass.cpp

2

I think we are missing tests for conjunction and disjunction with types that don't have a ::value but should never be instantiated because of short-circuiting.

71

We should be testing that is_base_of instead, since that's what the spec requests. Same for disjunction.

[philnik]

• Address comments

[ldionne]

libcxx/include/__type_traits/conjunction.h

27

It would be more idiomatic to use using type = ...; here and below.

libcxx/include/type_traits

481–487

I would consider moving these helpers to conjunction.h and disjunction.h in the future, with a small comment explaining how they differ from disjunction and conjunction.

libcxx/test/std/utilities/meta/meta.logical/conjunction.compile.pass.cpp

8

Can you please make sure that we have coverage for all the cases that were reported in https://github.com/llvm/llvm-project/issues/54803? The bug report has some nice tests we can easily add to our test suite in one form or another.

10

From live review: let's also make sure we allow types that have only an explicit cast to bool, since the standard says bool(Bi::value) (https://eel.is/c++draft/meta.logical).

77

Please add something like

static_assert(!std::conjunction<False, HasNoValue, True>::value);

We need to make sure that we can instantiate it, not only use is_base_of on it (yes, I know is_base_of will instantiate it, but that's only how our implementation works). Same applies for disjunction.

[philnik]

• Address comments

[philnik]

• Try to fix GCC

libcxx/docs/Status/Cxx17Issues.csv

 "`2503 <https://wg21.link/LWG2503>`__","multiline option should be added to syntax_option_type","Issaquah","|Complete|",""
 "`2510 <https://wg21.link/LWG2510>`__","Tag types should not be DefaultConstructible","Issaquah","|Complete|",""
 "`2514 <https://wg21.link/LWG2514>`__","Type traits must not be final","Issaquah","|Complete|",""
 "`2518 <https://wg21.link/LWG2518>`__","[fund.ts.v2] Non-member swap for propagate_const should call member swap","Issaquah","|Complete|",""
 "`2519 <https://wg21.link/LWG2519>`__","Iterator operator-= has gratuitous undefined behaviour","Issaquah","|Complete|",""
 "`2521 <https://wg21.link/LWG2521>`__","[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support","Issaquah","",""
 "`2525 <https://wg21.link/LWG2525>`__","[fund.ts.v2] get_memory_resource should be const and noexcept","Issaquah","",""
 "`2527 <https://wg21.link/LWG2527>`__","[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default","Issaquah","",""
-"`2531 <https://wg21.link/LWG2531>`__","future::get should explicitly state that the shared state is released","Issaquah","",""
+"`2531 <https://wg21.link/LWG2531>`__","future::get should explicitly state that the shared state is released","Issaquah","|Nothing To Do|",""
 "`2534 <https://wg21.link/LWG2534>`__","Constrain rvalue stream operators","Issaquah","|Complete|",""
 "`2536 <https://wg21.link/LWG2536>`__","What should <complex.h> do?","Issaquah","|Complete|",""
 "`2540 <https://wg21.link/LWG2540>`__","unordered_multimap::insert hint iterator","Issaquah","|Complete|",""
 "`2543 <https://wg21.link/LWG2543>`__","LWG 2148 (hash support for enum types) seems under-specified","Issaquah","|Complete|",""
 "`2544 <https://wg21.link/LWG2544>`__","``istreambuf_iterator(basic_streambuf<charT, traits>* s)``\  effects unclear when s is 0","Issaquah","|Complete|",""
 "`2556 <https://wg21.link/LWG2556>`__","Wide contract for future::share()","Issaquah","|Complete|",""
 "`2562 <https://wg21.link/LWG2562>`__","Consistent total ordering of pointers by comparison functors","Issaquah","",""
 "`2567 <https://wg21.link/LWG2567>`__","Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits","Issaquah","|Complete|",""
-"`2568 <https://wg21.link/LWG2568>`__","[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits","Issaquah","",""
-"`2569 <https://wg21.link/LWG2569>`__","conjunction and disjunction requirements are too strict","Issaquah","|Complete|",""
+"`2568 <https://wg21.link/LWG2568>`__","[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits","Issaquah","|Complete|","15.0"
+"`2569 <https://wg21.link/LWG2569>`__","conjunction and disjunction requirements are too strict","Issaquah","|Complete|","15.0"
 "`2570 <https://wg21.link/LWG2570>`__","[fund.ts.v2] conjunction and disjunction requirements are too strict","Issaquah","",""
 "`2578 <https://wg21.link/LWG2578>`__","Iterator requirements should reference iterator traits","Issaquah","|Complete|",""
 "`2584 <https://wg21.link/LWG2584>`__","<regex> ECMAScript IdentityEscape is ambiguous","Issaquah","",""
 "`2587 <https://wg21.link/LWG2587>`__","""Convertible to bool"" requirement in conjunction and disjunction","Issaquah","Resolved by 2567",""
-"`2588 <https://wg21.link/LWG2588>`__","[fund.ts.v2] ""Convertible to bool"" requirement in conjunction and disjunction","Issaquah","",""
+"`2588 <https://wg21.link/LWG2588>`__","[fund.ts.v2] ""Convertible to bool"" requirement in conjunction and disjunction","Issaquah","Resolved by 2568",""
 "`2589 <https://wg21.link/LWG2589>`__","match_results can't satisfy the requirements of a container","Issaquah","|Complete|",""
 "`2591 <https://wg21.link/LWG2591>`__","std::function's member template target() should not lead to undefined behaviour","Issaquah","|Complete|",""
 "`2598 <https://wg21.link/LWG2598>`__","addressof works on temporaries","Issaquah","|Complete|",""
 "`2664 <https://wg21.link/LWG2664>`__","operator/ (and other append) semantics not useful if argument has root","Issaquah","|Complete|",""
 "`2665 <https://wg21.link/LWG2665>`__","remove_filename() post condition is incorrect","Issaquah","|Complete|",""
 "`2672 <https://wg21.link/LWG2672>`__","Should ``is_empty``\  use error_code in its specification?","Issaquah","|Complete|",""
 "`2678 <https://wg21.link/LWG2678>`__","std::filesystem enum classes overspecified","Issaquah","|Complete|",""
 "`2679 <https://wg21.link/LWG2679>`__","Inconsistent Use of Effects and Equivalent To","Issaquah","|Complete|",""

 "`2740 <https://wg21.link/LWG2740>`__","constexpr optional<T>::operator->","Issaquah","|Complete|",""
 "`2742 <https://wg21.link/LWG2742>`__","Inconsistent string interface taking string_view","Issaquah","|Complete|",""
 "`2744 <https://wg21.link/LWG2744>`__","any's in_place constructors","Issaquah","|Complete|",""
 "`2745 <https://wg21.link/LWG2745>`__","[fund.ts.v2] Implementability of LWG 2451","Issaquah","|Complete|",""
 "`2747 <https://wg21.link/LWG2747>`__","Possibly redundant std::move in [alg.foreach]","Issaquah","|Complete|",""
 "`2748 <https://wg21.link/LWG2748>`__","swappable traits for optionals","Issaquah","|Complete|",""
 "`2749 <https://wg21.link/LWG2749>`__","swappable traits for variants","Issaquah","|Complete|",""
 "`2750 <https://wg21.link/LWG2750>`__","[fund.ts.v2] LWG 2451 conversion constructor constraint","Issaquah","|Nothing To Do|",""
-"`2752 <https://wg21.link/LWG2752>`__","""Throws:"" clauses of async and packaged_task are unimplementable","Issaquah","",""
+"`2752 <https://wg21.link/LWG2752>`__","""Throws:"" clauses of async and packaged_task are unimplementable","Issaquah","|Nothing To Do|",""
 "`2755 <https://wg21.link/LWG2755>`__","[string.view.io] uses non-existent basic_string_view::to_string function","Issaquah","|Complete|",""
 "`2756 <https://wg21.link/LWG2756>`__","C++ WP optional<T> should 'forward' T's implicit conversions","Issaquah","|Complete|",""
 "`2758 <https://wg21.link/LWG2758>`__","std::string{}.assign(""ABCDE"", 0, 1) is ambiguous","Issaquah","|Complete|",""
 "`2759 <https://wg21.link/LWG2759>`__","gcd / lcm and bool for the WP","Issaquah","|Complete|",""
 "`2760 <https://wg21.link/LWG2760>`__","non-const basic_string::data should not invalidate iterators","Issaquah","|Complete|",""
 "`2765 <https://wg21.link/LWG2765>`__","Did LWG 1123 go too far?","Issaquah","|Complete|",""
 "`2767 <https://wg21.link/LWG2767>`__","not_fn call_wrapper can form invalid types","Issaquah","|Complete|",""
 "`2769 <https://wg21.link/LWG2769>`__","Redundant const in the return type of any_cast(const any&)","Issaquah","|Complete|",""

 "`2857 <https://wg21.link/LWG2857>`__","{variant,optional,any}::emplace should return the constructed value","Kona","|Complete|",""
 "`2861 <https://wg21.link/LWG2861>`__","basic_string should require that charT match traits::char_type","Kona","|Complete|",""
 "`2866 <https://wg21.link/LWG2866>`__","Incorrect derived classes constraints","Kona","|Nothing To Do|",""
 "`2868 <https://wg21.link/LWG2868>`__","Missing specification of bad_any_cast::what()","Kona","|Complete|",""
 "`2872 <https://wg21.link/LWG2872>`__","Add definition for direct-non-list-initialization","Kona","|Complete|",""
 "`2873 <https://wg21.link/LWG2873>`__","Add noexcept to several shared_ptr related functions","Kona","|Complete|",""
 "`2874 <https://wg21.link/LWG2874>`__","Constructor ``shared_ptr::shared_ptr(Y*)``\  should be constrained","Kona","|Complete|","13.0"
 "`2875 <https://wg21.link/LWG2875>`__","shared_ptr::shared_ptr(Y\*, D, [|hellip|\ ]) constructors should be constrained","Kona","|Complete|",""
-"`2876 <https://wg21.link/LWG2876>`__","``shared_ptr::shared_ptr(const weak_ptr<Y>&)``\  constructor should be constrained","Kona","",""
+"`2876 <https://wg21.link/LWG2876>`__","``shared_ptr::shared_ptr(const weak_ptr<Y>&)``\  constructor should be constrained","Kona","|Complete|","14.0"
 "`2878 <https://wg21.link/LWG2878>`__","Missing DefaultConstructible requirement for istream_iterator default constructor","Kona","|Complete|",""
 "`2890 <https://wg21.link/LWG2890>`__","The definition of 'object state' applies only to class types","Kona","|Complete|",""
 "`2900 <https://wg21.link/LWG2900>`__","The copy and move constructors of optional are not constexpr","Kona","|Complete|",""
 "`2903 <https://wg21.link/LWG2903>`__","The form of initialization for the emplace-constructors is not specified","Kona","|Complete|",""
 "`2904 <https://wg21.link/LWG2904>`__","Make variant move-assignment more exception safe","Kona","|Complete|",""
 "`2905 <https://wg21.link/LWG2905>`__","is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible","Kona","|Complete|",""
 "`2908 <https://wg21.link/LWG2908>`__","The less-than operator for shared pointers could do more","Kona","|Complete|",""
 "`2911 <https://wg21.link/LWG2911>`__","An is_aggregate type trait is needed","Kona","|Complete|",""
 "`2921 <https://wg21.link/LWG2921>`__","packaged_task and type-erased allocators","Kona","|Complete|",""
 "`2934 <https://wg21.link/LWG2934>`__","optional<const T> doesn't compare with T","Kona","|Complete|",""
 "","","","",""
 "`2901 <https://wg21.link/LWG2901>`__","Variants cannot properly support allocators","Toronto","|Complete|",""
 "`2955 <https://wg21.link/LWG2955>`__","``to_chars / from_chars``\  depend on ``std::string``\ ","Toronto","Resolved by `P0682R1 <https://wg21.link/P0682R1>`__",""
 "`2956 <https://wg21.link/LWG2956>`__","``filesystem::canonical()``\  still defined in terms of ``absolute(p, base)``\ ","Toronto","|Complete|",""

libcxx/include/CMakeLists.txt

set(files
   __support/xlocale/__nop_locale_mgmt.h
   __support/xlocale/__posix_l_fallback.h
   __support/xlocale/__strtonum_fallback.h
   __thread/poll_with_backoff.h
   __thread/timed_backoff_policy.h
   __threading_support
   __tree
   __tuple
+  __type_traits/conditional.h
+  __type_traits/conjunction.h
+  __type_traits/disjunction.h
   __type_traits/integral_constant.h
   __type_traits/is_callable.h
   __undef_macros
   __utility/as_const.h
   __utility/auto_cast.h
   __utility/cmp.h
   __utility/declval.h
   __utility/exchange.h

libcxx/include/__type_traits/conditional.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_CONDITIONAL_H
+#define _LIBCPP___TYPE_TRAITS_CONDITIONAL_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <bool _Bp, class _If, class _Then>
+    struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};
+template <class _If, class _Then>
+    struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> {typedef _Then type;};
+
+#if _LIBCPP_STD_VER > 11
+template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_CONDITIONAL_H

libcxx/include/__type_traits/conjunction.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_CONJUNCTION_H
+#define _LIBCPP___TYPE_TRAITS_CONJUNCTION_H
+
+#include <__config>
+#include <__type_traits/conditional.h>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 14
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Arg, class... _Args>
+struct __conjunction_impl {
+  using type = conditional_t<!bool(_Arg::value), _Arg, typename __conjunction_impl<_Args...>::type>;
+};
+
+template <class _Arg>
+struct __conjunction_impl<_Arg> {
+  using type = _Arg;
+};
+
+template <class... _Args>
+struct conjunction : __conjunction_impl<true_type, _Args...>::type {};
+
+template<class... _Args>
+inline constexpr bool conjunction_v = conjunction<_Args...>::value;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 14
+
+#endif // _LIBCPP___TYPE_TRAITS_CONJUNCTION_H

libcxx/include/__type_traits/disjunction.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_DISJUNCTION_H
+#define _LIBCPP___TYPE_TRAITS_DISJUNCTION_H
+
+#include <__config>
+#include <__type_traits/conditional.h>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 14
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Arg, class... _Args>
+struct __disjunction_impl {
+  using type = conditional_t<bool(_Arg::value), _Arg, typename __disjunction_impl<_Args...>::type>;
+};
+
+template <class _Arg>
+struct __disjunction_impl<_Arg> {
+  using type = _Arg;
+};
+
+template <class... _Args>
+struct disjunction : __disjunction_impl<false_type, _Args...>::type {};
+template<class... _Args>
+inline constexpr bool disjunction_v = disjunction<_Args...>::value;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 14
+
+#endif // _LIBCPP___TYPE_TRAITS_DISJUNCTION_H

libcxx/include/module.modulemap

module tuple {
     header "tuple"
     export *
   }
   module type_traits {
     header "type_traits"
     export functional.__functional.unwrap_ref
     export *
 
+    module conditional       { private header "__type_traits/conditional.h" }
+    module conjunction       { private header "__type_traits/conjunction.h" }
+    module disjunction       { private header "__type_traits/disjunction.h" }
     module integral_constant { private header "__type_traits/integral_constant.h" }
     module is_callable       { private header "__type_traits/is_callable.h" }
   }
   module typeindex {
     header "typeindex"
     export *
   }
   module typeinfo {

libcxx/include/type_traits

template <class...>
       template<class B>
         inline constexpr bool negation_v = negation<B>::value;           // C++17
 
 }
 
 */
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__type_traits/conditional.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/disjunction.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_callable.h>
 #include <__utility/declval.h>
 #include <cstddef>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

 using _Or _LIBCPP_NODEBUG = typename _MetaBase< sizeof...(_Rest) != 0 >::template _OrImpl<false_type, _Rest...>;
 template <class _Pred>
 struct _Not : _BoolConstant<!_Pred::value> {};
 template <class ..._Args>
 using _FirstType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 1)>::template _FirstImpl<_Args...>;
 template <class ..._Args>
 using _SecondType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 2)>::template _SecondImpl<_Args...>;
 
 template <class ...> using __expand_to_true = true_type;
 template <class ..._Pred>
 __expand_to_true<__enable_if_t<_Pred::value>...> __and_helper(int);
 template <class ...>
 false_type __and_helper(...);
 template <class ..._Pred>
 using _And _LIBCPP_NODEBUG = decltype(__and_helper<_Pred...>(0));
 
 template <template <class...> class _Func, class ..._Args>
 struct _Lazy : _Func<_Args...> {};
 
 // Member detector base
 
 template <template <class...> class _Templ, class ..._Args, class = _Templ<_Args...> >
 true_type __sfinae_test_impl(int);
 template <template <class...> class, class ...>
 false_type __sfinae_test_impl(...);
 
 template <template <class ...> class _Templ, class ..._Args>
 using _IsValidExpansion _LIBCPP_NODEBUG = decltype(__sfinae_test_impl<_Templ, _Args...>(0));
 
 template <class>
 struct __void_t { typedef void type; };
 
 template <class _Tp, bool>
 struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {};
 
-
-template <bool _Bp, class _If, class _Then>
-    struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};
-template <class _If, class _Then>
-    struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> {typedef _Then type;};
-
-#if _LIBCPP_STD_VER > 11
-template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
-#endif
-
 // is_same
 
 template <class _Tp, class _Up>
 struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> { };
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp, class _Up>
 inline constexpr bool is_same_v = __is_same(_Tp, _Up);

 struct _LIBCPP_TEMPLATE_VIS is_scoped_enum
     : public __is_scoped_enum_helper<_Tp> {};
 
 template <class _Tp>
 inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
 #endif
 
 #if _LIBCPP_STD_VER > 14
-
-template <class... _Args>
-struct conjunction : _And<_Args...> {};
-template<class... _Args>
-inline constexpr bool conjunction_v = conjunction<_Args...>::value;
-
-template <class... _Args>
-struct disjunction : _Or<_Args...> {};
-template<class... _Args>
-inline constexpr bool disjunction_v = disjunction<_Args...>::value;
-
 template <class _Tp>
 struct negation : _Not<_Tp> {};
 template<class _Tp>
 inline constexpr bool negation_v = negation<_Tp>::value;
 #endif // _LIBCPP_STD_VER > 14
 
 // These traits are used in __tree and __hash_table
 struct __extract_key_fail_tag {};

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
 #include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
 #include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
 #include <__std_stream> // expected-error@*:* {{use of private header from outside its module: '__std_stream'}}
 #include <__string> // expected-error@*:* {{use of private header from outside its module: '__string'}}
 #include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
 #include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
 #include <__tuple> // expected-error@*:* {{use of private header from outside its module: '__tuple'}}
+#include <__type_traits/conditional.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/conditional.h'}}
+#include <__type_traits/conjunction.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/conjunction.h'}}
+#include <__type_traits/disjunction.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/disjunction.h'}}
 #include <__type_traits/integral_constant.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/integral_constant.h'}}
 #include <__type_traits/is_callable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_callable.h'}}
 #include <__utility/as_const.h> // expected-error@*:* {{use of private header from outside its module: '__utility/as_const.h'}}
 #include <__utility/auto_cast.h> // expected-error@*:* {{use of private header from outside its module: '__utility/auto_cast.h'}}
 #include <__utility/cmp.h> // expected-error@*:* {{use of private header from outside its module: '__utility/cmp.h'}}
 #include <__utility/declval.h> // expected-error@*:* {{use of private header from outside its module: '__utility/declval.h'}}
 #include <__utility/exchange.h> // expected-error@*:* {{use of private header from outside its module: '__utility/exchange.h'}}
 #include <__utility/forward.h> // expected-error@*:* {{use of private header from outside its module: '__utility/forward.h'}}

libcxx/test/std/utilities/meta/meta.logical/conjunction.compile.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: c++03, c++11, c++14
+// type_traits
+
+// template<class... B> struct conjunction;                           // C++17
+// template<class... B>
+//   constexpr bool conjunction_v = conjunction<B...>::value;         // C++17
+
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+
+struct True  { static constexpr bool value = true; };
+struct False { static constexpr bool value = false; };
+
+struct MySpecialTrueType { static constexpr auto value = true; static constexpr auto MySpecial = 23; };
+struct MyOtherSpecialTrueType { static constexpr auto value = -1; static constexpr auto MySpecial = 46; };
+struct MySpecialFalseType { static constexpr auto value = false; static constexpr auto MySpecial = 37; };
+struct HasNoValue {};
+struct ExplicitlyConvertibleToBool { explicit constexpr operator bool() const { return true; } };
+struct ValueExplicitlyConvertible { static constexpr ExplicitlyConvertibleToBool value {}; };
+
+static_assert( std::conjunction<>::value);
+static_assert( std::conjunction<std::true_type >::value);
+static_assert(!std::conjunction<std::false_type>::value);
+
+static_assert( std::conjunction_v<>);
+static_assert( std::conjunction_v<std::true_type >);
+static_assert(!std::conjunction_v<std::false_type>);
+
+static_assert( std::conjunction<std::true_type,  std::true_type >::value);
+static_assert(!std::conjunction<std::true_type,  std::false_type>::value);
+static_assert(!std::conjunction<std::false_type, std::true_type >::value);
+static_assert(!std::conjunction<std::false_type, std::false_type>::value);
+
+static_assert( std::conjunction_v<std::true_type,  std::true_type >);
+static_assert(!std::conjunction_v<std::true_type,  std::false_type>);
+static_assert(!std::conjunction_v<std::false_type, std::true_type >);
+static_assert(!std::conjunction_v<std::false_type, std::false_type>);
+
+static_assert( std::conjunction<std::true_type,  std::true_type,  std::true_type >::value);
+static_assert(!std::conjunction<std::true_type,  std::false_type, std::true_type >::value);
+static_assert(!std::conjunction<std::false_type, std::true_type,  std::true_type >::value);
+static_assert(!std::conjunction<std::false_type, std::false_type, std::true_type >::value);
+static_assert(!std::conjunction<std::true_type,  std::true_type,  std::false_type>::value);
+static_assert(!std::conjunction<std::true_type,  std::false_type, std::false_type>::value);
+static_assert(!std::conjunction<std::false_type, std::true_type,  std::false_type>::value);
+static_assert(!std::conjunction<std::false_type, std::false_type, std::false_type>::value);
+
+static_assert( std::conjunction_v<std::true_type,  std::true_type,  std::true_type >);
+static_assert(!std::conjunction_v<std::true_type,  std::false_type, std::true_type >);
+static_assert(!std::conjunction_v<std::false_type, std::true_type,  std::true_type >);
+static_assert(!std::conjunction_v<std::false_type, std::false_type, std::true_type >);
+static_assert(!std::conjunction_v<std::true_type,  std::true_type,  std::false_type>);
+static_assert(!std::conjunction_v<std::true_type,  std::false_type, std::false_type>);
+static_assert(!std::conjunction_v<std::false_type, std::true_type,  std::false_type>);
+static_assert(!std::conjunction_v<std::false_type, std::false_type, std::false_type>);
+
+static_assert( std::conjunction<True >::value);
+static_assert(!std::conjunction<False>::value);
+
+static_assert( std::conjunction_v<True >);
+static_assert(!std::conjunction_v<False>);
+
+static_assert(std::is_base_of_v<MySpecialTrueType, std::conjunction<MyOtherSpecialTrueType, MySpecialTrueType>>);
+static_assert(std::is_base_of_v<MyOtherSpecialTrueType, std::conjunction<MySpecialTrueType, MyOtherSpecialTrueType>>);
+static_assert(std::is_base_of_v<MySpecialFalseType, std::conjunction<MySpecialFalseType, MyOtherSpecialTrueType>>);
+static_assert(std::is_base_of_v<MySpecialFalseType, std::conjunction<MyOtherSpecialTrueType, MySpecialFalseType>>);
+
+static_assert(std::is_base_of_v<std::false_type, std::conjunction<std::false_type, HasNoValue>>);
+
+static_assert(!std::conjunction<std::false_type, HasNoValue>::value);
+static_assert(!std::conjunction_v<std::false_type, HasNoValue>);
+
+static_assert(std::conjunction<MyOtherSpecialTrueType>::value == -1);
+static_assert(std::conjunction_v<MyOtherSpecialTrueType>);
+
+static_assert(std::is_base_of_v<ValueExplicitlyConvertible, std::conjunction<ValueExplicitlyConvertible>>);
+static_assert(std::conjunction_v<ValueExplicitlyConvertible, std::true_type>);

libcxx/test/std/utilities/meta/meta.logical/conjunction.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: c++03, c++11, c++14
-// type_traits
-
-// template<class... B> struct conjunction;                           // C++17
-// template<class... B>
-//   constexpr bool conjunction_v = conjunction<B...>::value;         // C++17
-
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-struct True  { static constexpr bool value = true; };
-struct False { static constexpr bool value = false; };
-
-int main(int, char**)
-{
-    static_assert ( std::conjunction<>::value, "" );
-    static_assert ( std::conjunction<std::true_type >::value, "" );
-    static_assert (!std::conjunction<std::false_type>::value, "" );
-
-    static_assert ( std::conjunction_v<>, "" );
-    static_assert ( std::conjunction_v<std::true_type >, "" );
-    static_assert (!std::conjunction_v<std::false_type>, "" );
-
-    static_assert ( std::conjunction<std::true_type,  std::true_type >::value, "" );
-    static_assert (!std::conjunction<std::true_type,  std::false_type>::value, "" );
-    static_assert (!std::conjunction<std::false_type, std::true_type >::value, "" );
-    static_assert (!std::conjunction<std::false_type, std::false_type>::value, "" );
-
-    static_assert ( std::conjunction_v<std::true_type,  std::true_type >, "" );
-    static_assert (!std::conjunction_v<std::true_type,  std::false_type>, "" );
-    static_assert (!std::conjunction_v<std::false_type, std::true_type >, "" );
-    static_assert (!std::conjunction_v<std::false_type, std::false_type>, "" );
-
-    static_assert ( std::conjunction<std::true_type,  std::true_type,  std::true_type >::value, "" );
-    static_assert (!std::conjunction<std::true_type,  std::false_type, std::true_type >::value, "" );
-    static_assert (!std::conjunction<std::false_type, std::true_type,  std::true_type >::value, "" );
-    static_assert (!std::conjunction<std::false_type, std::false_type, std::true_type >::value, "" );
-    static_assert (!std::conjunction<std::true_type,  std::true_type,  std::false_type>::value, "" );
-    static_assert (!std::conjunction<std::true_type,  std::false_type, std::false_type>::value, "" );
-    static_assert (!std::conjunction<std::false_type, std::true_type,  std::false_type>::value, "" );
-    static_assert (!std::conjunction<std::false_type, std::false_type, std::false_type>::value, "" );
-
-    static_assert ( std::conjunction_v<std::true_type,  std::true_type,  std::true_type >, "" );
-    static_assert (!std::conjunction_v<std::true_type,  std::false_type, std::true_type >, "" );
-    static_assert (!std::conjunction_v<std::false_type, std::true_type,  std::true_type >, "" );
-    static_assert (!std::conjunction_v<std::false_type, std::false_type, std::true_type >, "" );
-    static_assert (!std::conjunction_v<std::true_type,  std::true_type,  std::false_type>, "" );
-    static_assert (!std::conjunction_v<std::true_type,  std::false_type, std::false_type>, "" );
-    static_assert (!std::conjunction_v<std::false_type, std::true_type,  std::false_type>, "" );
-    static_assert (!std::conjunction_v<std::false_type, std::false_type, std::false_type>, "" );
-
-    static_assert ( std::conjunction<True >::value, "" );
-    static_assert (!std::conjunction<False>::value, "" );
-
-    static_assert ( std::conjunction_v<True >, "" );
-    static_assert (!std::conjunction_v<False>, "" );
-
-  return 0;
-}

libcxx/test/std/utilities/meta/meta.logical/disjunction.compile.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: c++03, c++11, c++14
+// type_traits
+
+// template<class... B> struct disjunction;                           // C++17
+// template<class... B>
+//   constexpr bool disjunction_v = disjunction<B...>::value;         // C++17
+
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct True  { static constexpr bool value = true; };
+struct False { static constexpr bool value = false; };
+
+struct MySpecialTrueType { static constexpr auto value = -1; static constexpr auto MySpecial = 37; };
+struct MySpecialFalseType { static constexpr auto value = false; static constexpr auto MySpecial = 23; };
+struct MyOtherSpecialFalseType { static constexpr auto value = false; static constexpr auto MySpecial = 46; };
+struct HasNoValue {};
+struct ExplicitlyConvertibleToBool { explicit constexpr operator bool() const { return false; } };
+struct ValueExplicitlyConvertible { static constexpr ExplicitlyConvertibleToBool value {}; };
+
+static_assert(!std::disjunction<>::value);
+static_assert( std::disjunction<std::true_type >::value);
+static_assert(!std::disjunction<std::false_type>::value);
+
+static_assert(!std::disjunction_v<>);
+static_assert( std::disjunction_v<std::true_type >);
+static_assert(!std::disjunction_v<std::false_type>);
+
+static_assert( std::disjunction<std::true_type,  std::true_type >::value);
+static_assert( std::disjunction<std::true_type,  std::false_type>::value);
+static_assert( std::disjunction<std::false_type, std::true_type >::value);
+static_assert(!std::disjunction<std::false_type, std::false_type>::value);
+
+static_assert( std::disjunction_v<std::true_type,  std::true_type >);
+static_assert( std::disjunction_v<std::true_type,  std::false_type>);
+static_assert( std::disjunction_v<std::false_type, std::true_type >);
+static_assert(!std::disjunction_v<std::false_type, std::false_type>);
+
+static_assert( std::disjunction<std::true_type,  std::true_type,  std::true_type >::value);
+static_assert( std::disjunction<std::true_type,  std::false_type, std::true_type >::value);
+static_assert( std::disjunction<std::false_type, std::true_type,  std::true_type >::value);
+static_assert( std::disjunction<std::false_type, std::false_type, std::true_type >::value);
+static_assert( std::disjunction<std::true_type,  std::true_type,  std::false_type>::value);
+static_assert( std::disjunction<std::true_type,  std::false_type, std::false_type>::value);
+static_assert( std::disjunction<std::false_type, std::true_type,  std::false_type>::value);
+static_assert(!std::disjunction<std::false_type, std::false_type, std::false_type>::value);
+
+static_assert( std::disjunction_v<std::true_type,  std::true_type,  std::true_type >);
+static_assert( std::disjunction_v<std::true_type,  std::false_type, std::true_type >);
+static_assert( std::disjunction_v<std::false_type, std::true_type,  std::true_type >);
+static_assert( std::disjunction_v<std::false_type, std::false_type, std::true_type >);
+static_assert( std::disjunction_v<std::true_type,  std::true_type,  std::false_type>);
+static_assert( std::disjunction_v<std::true_type,  std::false_type, std::false_type>);
+static_assert( std::disjunction_v<std::false_type, std::true_type,  std::false_type>);
+static_assert(!std::disjunction_v<std::false_type, std::false_type, std::false_type>);
+
+static_assert ( std::disjunction<True >::value, "" );
+static_assert (!std::disjunction<False>::value, "" );
+
+static_assert ( std::disjunction_v<True >, "" );
+static_assert (!std::disjunction_v<False>, "" );
+
+static_assert(std::is_base_of_v<MySpecialFalseType, std::disjunction<MyOtherSpecialFalseType, MySpecialFalseType>>);
+static_assert(std::is_base_of_v<MyOtherSpecialFalseType, std::disjunction<MySpecialFalseType, MyOtherSpecialFalseType>>);
+static_assert(std::is_base_of_v<MySpecialTrueType, std::disjunction<MySpecialTrueType, MyOtherSpecialFalseType>>);
+static_assert(std::is_base_of_v<MySpecialTrueType, std::disjunction<MyOtherSpecialFalseType, MySpecialTrueType>>);
+
+static_assert(std::is_base_of_v<std::true_type, std::disjunction<std::true_type, HasNoValue>>);
+
+static_assert(std::disjunction<std::true_type, HasNoValue>::value);
+static_assert(std::disjunction_v<std::true_type, HasNoValue>);
+
+static_assert(std::disjunction<MySpecialTrueType>::value == -1);
+static_assert(std::disjunction_v<MySpecialTrueType>);
+
+static_assert(std::is_base_of_v<ValueExplicitlyConvertible, std::disjunction<ValueExplicitlyConvertible>>);
+static_assert(std::disjunction_v<ValueExplicitlyConvertible, std::true_type>);

libcxx/test/std/utilities/meta/meta.logical/disjunction.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: c++03, c++11, c++14
-// type_traits
-
-// template<class... B> struct disjunction;                           // C++17
-// template<class... B>
-//   constexpr bool disjunction_v = disjunction<B...>::value;         // C++17
-
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-struct True  { static constexpr bool value = true; };
-struct False { static constexpr bool value = false; };
-
-int main(int, char**)
-{
-    static_assert (!std::disjunction<>::value, "" );
-    static_assert ( std::disjunction<std::true_type >::value, "" );
-    static_assert (!std::disjunction<std::false_type>::value, "" );
-
-    static_assert (!std::disjunction_v<>, "" );
-    static_assert ( std::disjunction_v<std::true_type >, "" );
-    static_assert (!std::disjunction_v<std::false_type>, "" );
-
-    static_assert ( std::disjunction<std::true_type,  std::true_type >::value, "" );
-    static_assert ( std::disjunction<std::true_type,  std::false_type>::value, "" );
-    static_assert ( std::disjunction<std::false_type, std::true_type >::value, "" );
-    static_assert (!std::disjunction<std::false_type, std::false_type>::value, "" );
-
-    static_assert ( std::disjunction_v<std::true_type,  std::true_type >, "" );
-    static_assert ( std::disjunction_v<std::true_type,  std::false_type>, "" );
-    static_assert ( std::disjunction_v<std::false_type, std::true_type >, "" );
-    static_assert (!std::disjunction_v<std::false_type, std::false_type>, "" );
-
-    static_assert ( std::disjunction<std::true_type,  std::true_type,  std::true_type >::value, "" );
-    static_assert ( std::disjunction<std::true_type,  std::false_type, std::true_type >::value, "" );
-    static_assert ( std::disjunction<std::false_type, std::true_type,  std::true_type >::value, "" );
-    static_assert ( std::disjunction<std::false_type, std::false_type, std::true_type >::value, "" );
-    static_assert ( std::disjunction<std::true_type,  std::true_type,  std::false_type>::value, "" );
-    static_assert ( std::disjunction<std::true_type,  std::false_type, std::false_type>::value, "" );
-    static_assert ( std::disjunction<std::false_type, std::true_type,  std::false_type>::value, "" );
-    static_assert (!std::disjunction<std::false_type, std::false_type, std::false_type>::value, "" );
-
-    static_assert ( std::disjunction_v<std::true_type,  std::true_type,  std::true_type >, "" );
-    static_assert ( std::disjunction_v<std::true_type,  std::false_type, std::true_type >, "" );
-    static_assert ( std::disjunction_v<std::false_type, std::true_type,  std::true_type >, "" );
-    static_assert ( std::disjunction_v<std::false_type, std::false_type, std::true_type >, "" );
-    static_assert ( std::disjunction_v<std::true_type,  std::true_type,  std::false_type>, "" );
-    static_assert ( std::disjunction_v<std::true_type,  std::false_type, std::false_type>, "" );
-    static_assert ( std::disjunction_v<std::false_type, std::true_type,  std::false_type>, "" );
-    static_assert (!std::disjunction_v<std::false_type, std::false_type, std::false_type>, "" );
-
-    static_assert ( std::disjunction<True >::value, "" );
-    static_assert (!std::disjunction<False>::value, "" );
-
-    static_assert ( std::disjunction_v<True >, "" );
-    static_assert (!std::disjunction_v<False>, "" );
-
-  return 0;
-}