[libcxx] r329460 - Implement P0768r1: Library support for the Spaceship Operator.
Eric Fiselier via cfe-commits
cfe-commits at lists.llvm.org
Fri Apr 6 14:37:23 PDT 2018
Author: ericwf
Date: Fri Apr 6 14:37:23 2018
New Revision: 329460
URL: http://llvm.org/viewvc/llvm-project?rev=329460&view=rev
Log:
Implement P0768r1: Library support for the Spaceship Operator.
this patch adds the <compare> header and implements all of it
except for [comp.alg].
As I understand it, the header is needed by the compiler in
when implementing the semantics of operator<=>. For that reason
I feel it's important to land this header early, despite
all compilers lacking support.
Added:
libcxx/trunk/include/compare
libcxx/trunk/test/libcxx/language.support/cmp/
libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp
libcxx/trunk/test/std/language.support/cmp/
libcxx/trunk/test/std/language.support/cmp/cmp.common/
libcxx/trunk/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
libcxx/trunk/test/std/language.support/cmp/cmp.partialord/
libcxx/trunk/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/
libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
libcxx/trunk/test/std/language.support/cmp/cmp.strongord/
libcxx/trunk/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/
libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
libcxx/trunk/test/std/language.support/cmp/cmp.weakord/
libcxx/trunk/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
Modified:
libcxx/trunk/include/CMakeLists.txt
libcxx/trunk/include/__config
libcxx/trunk/include/module.modulemap
libcxx/trunk/test/libcxx/double_include.sh.cpp
libcxx/trunk/test/support/test_macros.h
Modified: libcxx/trunk/include/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/CMakeLists.txt?rev=329460&r1=329459&r2=329460&view=diff
==============================================================================
--- libcxx/trunk/include/CMakeLists.txt (original)
+++ libcxx/trunk/include/CMakeLists.txt Fri Apr 6 14:37:23 2018
@@ -77,5 +77,4 @@ if (LIBCXX_INSTALL_HEADERS)
add_custom_target(install-libcxx-headers DEPENDS install-cxx-headers)
add_custom_target(install-libcxx-headers-stripped DEPENDS install-cxx-headers-stripped)
endif()
-
endif()
Modified: libcxx/trunk/include/__config
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__config?rev=329460&r1=329459&r2=329460&view=diff
==============================================================================
--- libcxx/trunk/include/__config (original)
+++ libcxx/trunk/include/__config Fri Apr 6 14:37:23 2018
@@ -1196,6 +1196,11 @@ _LIBCPP_FUNC_VIS extern "C" void __sanit
#define _LIBCPP_HAS_NO_COROUTINES
#endif
+// FIXME: Correct this macro when either (A) a feature test macro for the
+// spaceship operator is provided, or (B) a compiler provides a complete
+// implementation.
+#define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
// Decide whether to use availability macros.
#if !defined(_LIBCPP_BUILDING_LIBRARY) && \
!defined(_LIBCPP_DISABLE_AVAILABILITY) && \
Added: libcxx/trunk/include/compare
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/compare?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/include/compare (added)
+++ libcxx/trunk/include/compare Fri Apr 6 14:37:23 2018
@@ -0,0 +1,679 @@
+// -*- C++ -*-
+//===-------------------------- compare -----------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_COMPARE
+#define _LIBCPP_COMPARE
+
+/*
+ compare synopsis
+
+namespace std {
+ // [cmp.categories], comparison category types
+ class weak_equality;
+ class strong_equality;
+ class partial_ordering;
+ class weak_ordering;
+ class strong_ordering;
+
+ // named comparison functions
+ constexpr bool is_eq (weak_equality cmp) noexcept { return cmp == 0; }
+ constexpr bool is_neq (weak_equality cmp) noexcept { return cmp != 0; }
+ constexpr bool is_lt (partial_ordering cmp) noexcept { return cmp < 0; }
+ constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
+ constexpr bool is_gt (partial_ordering cmp) noexcept { return cmp > 0; }
+ constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; }
+
+ // [cmp.common], common comparison category type
+ template<class... Ts>
+ struct common_comparison_category {
+ using type = see below;
+ };
+ template<class... Ts>
+ using common_comparison_category_t = typename common_comparison_category<Ts...>::type;
+
+ // [cmp.alg], comparison algorithms
+ template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
+ template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
+ template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
+ template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);
+ template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);
+}
+*/
+
+#include <__config>
+#include <type_traits>
+#include <array>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+// exposition only
+enum class _LIBCPP_ENUM_VIS _EqResult : unsigned char {
+ __zero = 0,
+ __equal = __zero,
+ __equiv = __equal,
+ __nonequal = 1,
+ __nonequiv = __nonequal
+};
+
+enum class _LIBCPP_ENUM_VIS _OrdResult : signed char {
+ __less = -1,
+ __greater = 1
+};
+
+enum class _LIBCPP_ENUM_VIS _NCmpResult : signed char {
+ __unordered = -127
+};
+
+struct _CmpUnspecifiedType;
+using _CmpUnspecifiedParam = void (_CmpUnspecifiedType::*)();
+
+class weak_equality {
+ _LIBCPP_INLINE_VISIBILITY
+ constexpr explicit weak_equality(_EqResult __val) noexcept : __value_(__val) {}
+
+public:
+ static const weak_equality equivalent;
+ static const weak_equality nonequivalent;
+
+ friend constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept;
+ friend constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept;
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+ friend constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept;
+#endif
+
+private:
+ _EqResult __value_;
+};
+
+_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::equivalent(_EqResult::__equiv);
+_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::nonequivalent(_EqResult::__nonequiv);
+
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ == _EqResult::__zero;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept {
+ return __v.__value_ == _EqResult::__zero;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ != _EqResult::__zero;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept {
+ return __v.__value_ != _EqResult::__zero;
+}
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept {
+ return __v;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept {
+ return __v;
+}
+#endif
+
+class strong_equality {
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr strong_equality(_EqResult __val) noexcept : __value_(__val) {}
+
+public:
+ static const strong_equality equal;
+ static const strong_equality nonequal;
+ static const strong_equality equivalent;
+ static const strong_equality nonequivalent;
+
+ // conversion
+ constexpr operator weak_equality() const noexcept {
+ return __value_ == _EqResult::__zero ? weak_equality::equivalent
+ : weak_equality::nonequivalent;
+ }
+
+ // comparisons
+ friend constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept;
+ friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept;
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+ friend constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept;
+#endif
+private:
+ _EqResult __value_;
+};
+
+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equal(_EqResult::__equal);
+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequal(_EqResult::__nonequal);
+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equivalent(_EqResult::__equiv);
+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequivalent(_EqResult::__nonequiv);
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ == _EqResult::__zero;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept {
+ return __v.__value_ == _EqResult::__zero;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ != _EqResult::__zero;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept {
+ return __v.__value_ != _EqResult::__zero;
+}
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+_LIBCPP_INLINE_VISIBILITY
+constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept {
+ return __v;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept {
+ return __v;
+}
+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
+class partial_ordering {
+ using _ValueT = signed char;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr partial_ordering(_EqResult __v) noexcept
+ : __value_(_ValueT(__v)) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr partial_ordering(_OrdResult __v) noexcept
+ : __value_(_ValueT(__v)) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr partial_ordering(_NCmpResult __v) noexcept
+ : __value_(_ValueT(__v)) {}
+
+ constexpr bool __is_ordered() const noexcept {
+ return __value_ != _ValueT(_NCmpResult::__unordered);
+ }
+public:
+ // valid values
+ static const partial_ordering less;
+ static const partial_ordering equivalent;
+ static const partial_ordering greater;
+ static const partial_ordering unordered;
+
+ // conversion
+ constexpr operator weak_equality() const noexcept {
+ return __value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
+ }
+
+ // comparisons
+ friend constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
+ friend constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
+ friend constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
+ friend constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
+ friend constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
+ friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+ friend constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
+#endif
+
+private:
+ _ValueT __value_;
+};
+
+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::less(_OrdResult::__less);
+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::equivalent(_EqResult::__equiv);
+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::greater(_OrdResult::__greater);
+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::unordered(_NCmpResult ::__unordered);
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__is_ordered() && __v.__value_ == 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__is_ordered() && __v.__value_ < 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__is_ordered() && __v.__value_ <= 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__is_ordered() && __v.__value_ > 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__is_ordered() && __v.__value_ >= 0;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
+ return __v.__is_ordered() && 0 == __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept {
+ return __v.__is_ordered() && 0 < __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
+ return __v.__is_ordered() && 0 <= __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept {
+ return __v.__is_ordered() && 0 > __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
+ return __v.__is_ordered() && 0 >= __v.__value_;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return !__v.__is_ordered() || __v.__value_ != 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
+ return !__v.__is_ordered() || __v.__value_ != 0;
+}
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+_LIBCPP_INLINE_VISIBILITY
+constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
+ return __v < 0 ? partial_ordering::greater : (__v > 0 ? partial_ordering::less : __v);
+}
+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
+class weak_ordering {
+ using _ValueT = signed char;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr weak_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr weak_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
+
+public:
+ static const weak_ordering less;
+ static const weak_ordering equivalent;
+ static const weak_ordering greater;
+
+ // conversions
+ _LIBCPP_INLINE_VISIBILITY
+ constexpr operator weak_equality() const noexcept {
+ return __value_ == 0 ? weak_equality::equivalent
+ : weak_equality::nonequivalent;
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ constexpr operator partial_ordering() const noexcept {
+ return __value_ == 0 ? partial_ordering::equivalent
+ : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
+ }
+
+ // comparisons
+ friend constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator!=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
+ friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
+ friend constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
+ friend constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
+ friend constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
+ friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+ friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
+#endif
+
+private:
+ _ValueT __value_;
+};
+
+_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::less(_OrdResult::__less);
+_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::equivalent(_EqResult::__equiv);
+_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::greater(_OrdResult::__greater);
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ == 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ != 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ < 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ <= 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ > 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ >= 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+ return 0 == __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+ return 0 != __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+ return 0 < __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+ return 0 <= __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+ return 0 > __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+ return 0 >= __v.__value_;
+}
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+_LIBCPP_INLINE_VISIBILITY
+constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+ return __v < 0 ? weak_ordering::greater : (__v > 0 ? weak_ordering::less : __v);
+}
+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
+class strong_ordering {
+ using _ValueT = signed char;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr strong_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit constexpr strong_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
+
+public:
+ static const strong_ordering less;
+ static const strong_ordering equal;
+ static const strong_ordering equivalent;
+ static const strong_ordering greater;
+
+ // conversions
+ _LIBCPP_INLINE_VISIBILITY
+ constexpr operator weak_equality() const noexcept {
+ return __value_ == 0 ? weak_equality::equivalent
+ : weak_equality::nonequivalent;
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ constexpr operator strong_equality() const noexcept {
+ return __value_ == 0 ? strong_equality::equal
+ : strong_equality::nonequal;
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ constexpr operator partial_ordering() const noexcept {
+ return __value_ == 0 ? partial_ordering::equivalent
+ : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ constexpr operator weak_ordering() const noexcept {
+ return __value_ == 0 ? weak_ordering::equivalent
+ : (__value_ < 0 ? weak_ordering::less : weak_ordering::greater);
+ }
+
+ // comparisons
+ friend constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator!=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
+ friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
+ friend constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
+ friend constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
+ friend constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
+ friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+ friend constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
+ friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
+#endif
+
+private:
+ _ValueT __value_;
+};
+
+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::less(_OrdResult::__less);
+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equal(_EqResult::__equal);
+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equivalent(_EqResult::__equiv);
+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater);
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ == 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ != 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ < 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ <= 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ > 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v.__value_ >= 0;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+ return 0 == __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+ return 0 != __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+ return 0 < __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+ return 0 <= __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+ return 0 > __v.__value_;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+ return 0 >= __v.__value_;
+}
+
+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+_LIBCPP_INLINE_VISIBILITY
+constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+ return __v;
+}
+_LIBCPP_INLINE_VISIBILITY
+constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+ return __v < 0 ? strong_ordering::greater : (__v > 0 ? strong_ordering::less : __v);
+}
+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
+// named comparison functions
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool is_eq(weak_equality __cmp) noexcept { return __cmp == 0; }
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool is_neq(weak_equality __cmp) noexcept { return __cmp != 0; }
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool is_lt(partial_ordering __cmp) noexcept { return __cmp < 0; }
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool is_lteq(partial_ordering __cmp) noexcept { return __cmp <= 0; }
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool is_gt(partial_ordering __cmp) noexcept { return __cmp > 0; }
+
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool is_gteq(partial_ordering __cmp) noexcept { return __cmp >= 0; }
+
+namespace __comp_detail {
+
+enum _ClassifyCompCategory : unsigned{
+ _None,
+ _WeakEq,
+ _StrongEq,
+ _PartialOrd,
+ _WeakOrd,
+ _StrongOrd,
+ _CCC_Size
+};
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+constexpr _ClassifyCompCategory __type_to_enum() noexcept {
+ if (is_same_v<_Tp, weak_equality>)
+ return _WeakEq;
+ if (is_same_v<_Tp, strong_equality>)
+ return _StrongEq;
+ if (is_same_v<_Tp, partial_ordering>)
+ return _PartialOrd;
+ if (is_same_v<_Tp, weak_ordering>)
+ return _WeakOrd;
+ if (is_same_v<_Tp, strong_ordering>)
+ return _StrongOrd;
+ return _None;
+}
+
+template <size_t _Size>
+constexpr _ClassifyCompCategory
+__compute_comp_type(std::array<_ClassifyCompCategory, _Size> __types) {
+ std::array<int, _CCC_Size> __seen = {};
+ for (auto __type : __types)
+ ++__seen[__type];
+ if (__seen[_None])
+ return _None;
+ if (__seen[_WeakEq])
+ return _WeakEq;
+ if (__seen[_StrongEq] && (__seen[_PartialOrd] || __seen[_WeakOrd]))
+ return _WeakEq;
+ if (__seen[_StrongEq])
+ return _StrongEq;
+ if (__seen[_PartialOrd])
+ return _PartialOrd;
+ if (__seen[_WeakOrd])
+ return _WeakOrd;
+ return _StrongOrd;
+}
+
+template <class ..._Ts>
+constexpr auto __get_comp_type() {
+ using _CCC = _ClassifyCompCategory;
+ constexpr array<_CCC, sizeof...(_Ts)> __type_kinds{__comp_detail::__type_to_enum<_Ts>()...};
+ constexpr _CCC _Cat = sizeof...(_Ts) == 0 ? _StrongOrd
+ : __compute_comp_type(__type_kinds);
+ if constexpr (_Cat == _None)
+ return ((void)0);
+ else if constexpr (_Cat == _WeakEq)
+ return weak_equality::equivalent;
+ else if constexpr (_Cat == _StrongEq)
+ return strong_equality::equivalent;
+ else if constexpr (_Cat == _PartialOrd)
+ return partial_ordering::equivalent;
+ else if constexpr (_Cat == _WeakOrd)
+ return weak_ordering::equivalent;
+ else if constexpr (_Cat == _StrongOrd)
+ return strong_ordering::equivalent;
+ else
+ static_assert(_Cat != _Cat, "unhandled case");
+}
+} // namespace __comp_detail
+
+// [cmp.common], common comparison category type
+template<class... _Ts>
+struct _LIBCPP_TEMPLATE_VIS common_comparison_category {
+ using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
+};
+
+template<class... _Ts>
+using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
+
+// [cmp.alg], comparison algorithms
+// TODO: unimplemented
+template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
+template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
+template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
+template<class _Tp> constexpr strong_equality strong_equal(const _Tp& __lhs, const _Tp& __rhs);
+template<class _Tp> constexpr weak_equality weak_equal(const _Tp& __lhs, const _Tp& __rhs);
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_COMPARE
Modified: libcxx/trunk/include/module.modulemap
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/module.modulemap?rev=329460&r1=329459&r2=329460&view=diff
==============================================================================
--- libcxx/trunk/include/module.modulemap (original)
+++ libcxx/trunk/include/module.modulemap Fri Apr 6 14:37:23 2018
@@ -243,6 +243,10 @@ module std [system] {
header "codecvt"
export *
}
+ module compare {
+ header "compare"
+ export *
+ }
module complex {
header "complex"
export *
Modified: libcxx/trunk/test/libcxx/double_include.sh.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/double_include.sh.cpp?rev=329460&r1=329459&r2=329460&view=diff
==============================================================================
--- libcxx/trunk/test/libcxx/double_include.sh.cpp (original)
+++ libcxx/trunk/test/libcxx/double_include.sh.cpp Fri Apr 6 14:37:23 2018
@@ -41,6 +41,7 @@
#include <clocale>
#include <cmath>
#include <codecvt>
+#include <compare>
#include <complex>
#include <complex.h>
#include <condition_variable>
Added: libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp (added)
+++ libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp Fri Apr 6 14:37:23 2018
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+// <compare>
+
+#include <compare>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}
Added: libcxx/trunk/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp (added)
+++ libcxx/trunk/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp Fri Apr 6 14:37:23 2018
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++98, c++03, c++11, c++14, c++17
+
+// <compare>
+
+// template <class ...Ts> struct common_comparison_category
+// template <class ...Ts> using common_comparison_category_t
+
+
+#include <compare>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+const volatile void* volatile sink;
+
+template <class Expect, class ...Args>
+void test_cat() {
+ using Cat = std::common_comparison_category<Args...>;
+ using CatT = typename Cat::type;
+ static_assert(std::is_same<CatT, std::common_comparison_category_t<Args...>>::value, "");
+ static_assert(std::is_same<CatT, Expect>::value, "expected different category");
+};
+
+
+// [class.spaceship]p4: The 'common comparison type' U of a possibly-empty list
+// of 'n' types T0, T1, ..., TN, is defined as follows:
+int main() {
+ using WE = std::weak_equality;
+ using SE = std::strong_equality;
+ using PO = std::partial_ordering;
+ using WO = std::weak_ordering;
+ using SO = std::strong_ordering;
+
+ // [class.spaceship]p4.1: If any Ti is not a comparison category tpe, U is void.
+ {
+ test_cat<void, void>();
+ test_cat<void, int*>();
+ test_cat<void, SO&>();
+ test_cat<void, SO const>();
+ test_cat<void, SO*>();
+ test_cat<void, SO, void, SO>();
+ }
+
+ // [class.spaceship]p4.2: Otherwise, if at least on Ti is
+ // std::weak_equality, or at least one Ti is std::strong_equality and at least
+ // one Tj is std::partial_ordering or std::weak_ordering, U is std::weak_equality
+ {
+ test_cat<WE, WE>();
+ test_cat<WE, SO, WE, SO>();
+ test_cat<WE, SE, SO, PO>();
+ test_cat<WE, WO, SO, SE>();
+ }
+
+ // [class.spaceship]p4.3: Otherwise, if at least one Ti is std::strong_equality,
+ // U is std::strong_equality
+ {
+ test_cat<SE, SE>();
+ test_cat<SE, SO, SE, SO>();
+ }
+
+ // [class.spaceship]p4.4: Otherwise, if at least one Ti is std::partial_ordering,
+ // U is std::partial_ordering
+ {
+ test_cat<PO, PO>();
+ test_cat<PO, SO, PO, SO>();
+ test_cat<PO, WO, PO, SO>();
+ }
+
+ // [class.spaceship]p4.5: Otherwise, if at least one Ti is std::weak_ordering,
+ // U is std::weak_ordering
+ {
+ test_cat<WO, WO>();
+ test_cat<WO, SO, WO, SO>();
+ }
+
+ // [class.spaceship]p4.6: Otherwise, U is std::strong_ordering. [Note: in
+ // particular this is the result when n is 0. -- end note]
+ {
+ test_cat<SO>(); // empty type list
+ test_cat<SO, SO>();
+ test_cat<SO, SO, SO>();
+ }
+}
Added: libcxx/trunk/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp (added)
+++ libcxx/trunk/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp Fri Apr 6 14:37:23 2018
@@ -0,0 +1,164 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++98, c++03, c++11, c++14, c++17
+
+// <compare>
+
+// class partial_ordering
+
+
+#include <compare>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+const volatile void* volatile sink;
+
+void test_static_members() {
+ DoNotOptimize(&std::partial_ordering::less);
+ DoNotOptimize(&std::partial_ordering::equivalent);
+ DoNotOptimize(&std::partial_ordering::greater);
+ DoNotOptimize(&std::partial_ordering::unordered);
+}
+
+void test_signatures() {
+ auto& Eq = std::partial_ordering::equivalent;
+
+ ASSERT_NOEXCEPT(Eq == 0);
+ ASSERT_NOEXCEPT(0 == Eq);
+ ASSERT_NOEXCEPT(Eq != 0);
+ ASSERT_NOEXCEPT(0 != Eq);
+ ASSERT_NOEXCEPT(0 < Eq);
+ ASSERT_NOEXCEPT(Eq < 0);
+ ASSERT_NOEXCEPT(0 <= Eq);
+ ASSERT_NOEXCEPT(Eq <= 0);
+ ASSERT_NOEXCEPT(0 > Eq);
+ ASSERT_NOEXCEPT(Eq > 0);
+ ASSERT_NOEXCEPT(0 >= Eq);
+ ASSERT_NOEXCEPT(Eq >= 0);
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ ASSERT_NOEXCEPT(0 <=> Eq);
+ ASSERT_NOEXCEPT(Eq <=> 0);
+ ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::partial_ordering);
+ ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::partial_ordering);
+#endif
+}
+
+constexpr bool test_conversion() {
+ static_assert(std::is_convertible<const std::partial_ordering, std::weak_equality>::value, "");
+ { // value == 0
+ auto V = std::partial_ordering::equivalent;
+ std::weak_equality WV = V;
+ assert(WV == 0);
+ }
+ std::partial_ordering TestCases[] = {
+ std::partial_ordering::less,
+ std::partial_ordering::greater,
+ std::partial_ordering::unordered
+ };
+ for (auto V : TestCases)
+ { // value != 0
+ std::weak_equality WV = V;
+ assert(WV != 0);
+ }
+ return true;
+}
+
+constexpr bool test_constexpr() {
+ auto& Eq = std::partial_ordering::equivalent;
+ auto& Less = std::partial_ordering::less;
+ auto& Greater = std::partial_ordering::greater;
+ auto& Unord = std::partial_ordering::unordered;
+ struct {
+ std::partial_ordering Value;
+ bool ExpectEq;
+ bool ExpectNeq;
+ bool ExpectLess;
+ bool ExpectGreater;
+ } TestCases[] = {
+ {Eq, true, false, false, false},
+ {Less, false, true, true, false},
+ {Greater, false, true, false, true},
+ {Unord, false, true, false, false}
+ };
+ for (auto TC : TestCases) {
+ auto V = TC.Value;
+ assert((V == 0) == TC.ExpectEq);
+ assert((0 == V) == TC.ExpectEq);
+ assert((V != 0) == TC.ExpectNeq);
+ assert((0 != V) == TC.ExpectNeq);
+
+ assert((V < 0) == TC.ExpectLess);
+ assert((V > 0) == TC.ExpectGreater);
+ assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
+ assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
+
+ assert((0 < V) == TC.ExpectGreater);
+ assert((0 > V) == TC.ExpectLess);
+ assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
+ assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
+ }
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ {
+ std::partial_ordering res = (Eq <=> 0);
+ ((void)res);
+ res = (0 <=> Eq);
+ ((void)res);
+ }
+ enum ExpectRes {
+ ER_Greater,
+ ER_Less,
+ ER_Equiv,
+ ER_Unord
+ };
+ struct {
+ std::partial_ordering Value;
+ ExpectRes Expect;
+ } SpaceshipTestCases[] = {
+ {std::partial_ordering::equivalent, ER_Equiv},
+ {std::partial_ordering::less, ER_Less},
+ {std::partial_ordering::greater, ER_Greater},
+ {std::partial_ordering::unordered, ER_Unord}
+ };
+ for (auto TC : SpaceshipTestCases)
+ {
+ std::partial_ordering Res = (0 <=> TC.Value);
+ switch (TC.Expect) {
+ case ER_Equiv:
+ assert(Res == 0);
+ assert(0 == Res);
+ break;
+ case ER_Less:
+ assert(Res < 0);
+ break;
+ case ER_Greater:
+ assert(Res > 0);
+ break;
+ case ER_Unord:
+ assert(Res != 0);
+ assert(0 != Res);
+ assert((Res < 0) == false);
+ assert((Res > 0) == false);
+ assert((Res == 0) == false);
+ break;
+ }
+ }
+#endif
+
+ return true;
+}
+
+int main() {
+ test_static_members();
+ test_signatures();
+ static_assert(test_conversion(), "conversion test failed");
+ static_assert(test_constexpr(), "constexpr test failed");
+}
Added: libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp (added)
+++ libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp Fri Apr 6 14:37:23 2018
@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++98, c++03, c++11, c++14, c++17
+
+// <compare>
+
+// class strong_equality
+
+
+#include <compare>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+const volatile void* volatile sink;
+
+void test_static_members() {
+ DoNotOptimize(&std::strong_equality::equal);
+ DoNotOptimize(&std::strong_equality::nonequal);
+ DoNotOptimize(&std::strong_equality::equivalent);
+ DoNotOptimize(&std::strong_equality::nonequivalent);
+}
+
+void test_signatures() {
+ auto& Eq = std::strong_equality::equivalent;
+
+ ASSERT_NOEXCEPT(Eq == 0);
+ ASSERT_NOEXCEPT(0 == Eq);
+ ASSERT_NOEXCEPT(Eq != 0);
+ ASSERT_NOEXCEPT(0 != Eq);
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ ASSERT_NOEXCEPT(0 <=> Eq);
+ ASSERT_NOEXCEPT(Eq <=> 0);
+ ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_equality);
+ ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_equality);
+#endif
+}
+
+void test_conversion() {
+ constexpr std::weak_equality res = std::strong_equality::equivalent;
+ static_assert(res == 0, "");
+ static_assert(std::is_convertible<const std::strong_equality&,
+ std::weak_equality>::value, "");
+ static_assert(res == 0, "expected equal");
+
+ constexpr std::weak_equality neq_res = std::strong_equality::nonequivalent;
+ static_assert(neq_res != 0, "expected not equal");
+}
+
+constexpr bool test_constexpr() {
+ auto& Eq = std::strong_equality::equal;
+ auto& NEq = std::strong_equality::nonequal;
+ auto& Equiv = std::strong_equality::equivalent;
+ auto& NEquiv = std::strong_equality::nonequivalent;
+ assert((Eq == 0) == true);
+ assert((0 == Eq) == true);
+ assert((Equiv == 0) == true);
+ assert((0 == Equiv) == true);
+ assert((NEq == 0) == false);
+ assert((0 == NEq) == false);
+ assert((NEquiv == 0) == false);
+ assert((0 == NEquiv) == false);
+
+ assert((Eq != 0) == false);
+ assert((0 != Eq) == false);
+ assert((Equiv != 0) == false);
+ assert((0 != Equiv) == false);
+ assert((NEq != 0) == true);
+ assert((0 != NEq) == true);
+ assert((NEquiv != 0) == true);
+ assert((0 != NEquiv) == true);
+
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ std::strong_equality res = (Eq <=> 0);
+ ((void)res);
+ res = (0 <=> Eq);
+ ((void)res);
+#endif
+
+ return true;
+}
+
+int main() {
+ test_static_members();
+ test_signatures();
+ test_conversion();
+ static_assert(test_constexpr(), "constexpr test failed");
+}
Added: libcxx/trunk/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp (added)
+++ libcxx/trunk/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp Fri Apr 6 14:37:23 2018
@@ -0,0 +1,212 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++98, c++03, c++11, c++14, c++17
+
+// <compare>
+
+// class strong_ordering
+
+
+#include <compare>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+const volatile void* volatile sink;
+
+void test_static_members() {
+ DoNotOptimize(&std::strong_ordering::less);
+ DoNotOptimize(&std::strong_ordering::equal);
+ DoNotOptimize(&std::strong_ordering::equivalent);
+ DoNotOptimize(&std::strong_ordering::greater);
+}
+
+void test_signatures() {
+ auto& Eq = std::strong_ordering::equivalent;
+
+ ASSERT_NOEXCEPT(Eq == 0);
+ ASSERT_NOEXCEPT(0 == Eq);
+ ASSERT_NOEXCEPT(Eq != 0);
+ ASSERT_NOEXCEPT(0 != Eq);
+ ASSERT_NOEXCEPT(0 < Eq);
+ ASSERT_NOEXCEPT(Eq < 0);
+ ASSERT_NOEXCEPT(0 <= Eq);
+ ASSERT_NOEXCEPT(Eq <= 0);
+ ASSERT_NOEXCEPT(0 > Eq);
+ ASSERT_NOEXCEPT(Eq > 0);
+ ASSERT_NOEXCEPT(0 >= Eq);
+ ASSERT_NOEXCEPT(Eq >= 0);
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ ASSERT_NOEXCEPT(0 <=> Eq);
+ ASSERT_NOEXCEPT(Eq <=> 0);
+ ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_ordering);
+ ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_ordering);
+#endif
+}
+
+constexpr bool test_conversion() {
+ static_assert(std::is_convertible<const std::strong_ordering&,
+ std::weak_equality>::value, "");
+ { // value == 0
+ auto V = std::strong_ordering::equivalent;
+ std::weak_equality WV = V;
+ assert(WV == 0);
+ }
+ std::strong_ordering WeakTestCases[] = {
+ std::strong_ordering::less,
+ std::strong_ordering::greater,
+ };
+ for (auto V : WeakTestCases)
+ { // value != 0
+ std::weak_equality WV = V;
+ assert(WV != 0);
+ }
+ static_assert(std::is_convertible<const std::strong_ordering&,
+ std::strong_equality>::value, "");
+ { // value == 0
+ auto V = std::strong_ordering::equivalent;
+ std::strong_equality WV = V;
+ assert(WV == 0);
+ }
+ { // value == 0
+ auto V = std::strong_ordering::equal;
+ std::strong_equality WV = V;
+ assert(WV == 0);
+ }
+ std::strong_ordering StrongTestCases[] = {
+ std::strong_ordering::less,
+ std::strong_ordering::greater,
+ };
+ for (auto V : StrongTestCases)
+ { // value != 0
+ std::strong_equality WV = V;
+ assert(WV != 0);
+ }
+
+ static_assert(std::is_convertible<const std::strong_ordering&,
+ std::partial_ordering>::value, "");
+ { // value == 0
+ auto V = std::strong_ordering::equivalent;
+ std::partial_ordering WV = V;
+ assert(WV == 0);
+ }
+ { // value < 0
+ auto V = std::strong_ordering::less;
+ std::partial_ordering WV = V;
+ assert(WV < 0);
+ }
+ { // value > 0
+ auto V = std::strong_ordering::greater;
+ std::partial_ordering WV = V;
+ assert(WV > 0);
+ }
+
+ static_assert(std::is_convertible<const std::strong_ordering&,
+ std::weak_ordering>::value, "");
+ { // value == 0
+ auto V = std::strong_ordering::equivalent;
+ std::weak_ordering WV = V;
+ assert(WV == 0);
+ }
+ { // value < 0
+ auto V = std::strong_ordering::less;
+ std::weak_ordering WV = V;
+ assert(WV < 0);
+ }
+ { // value > 0
+ auto V = std::strong_ordering::greater;
+ std::weak_ordering WV = V;
+ assert(WV > 0);
+ }
+ return true;
+}
+
+constexpr bool test_constexpr() {
+ auto& Eq = std::strong_ordering::equal;
+ auto& Equiv = std::strong_ordering::equivalent;
+ auto& Less = std::strong_ordering::less;
+ auto& Greater = std::strong_ordering::greater;
+ struct {
+ std::strong_ordering Value;
+ bool ExpectEq;
+ bool ExpectNeq;
+ bool ExpectLess;
+ bool ExpectGreater;
+ } TestCases[] = {
+ {Eq, true, false, false, false},
+ {Equiv, true, false, false, false},
+ {Less, false, true, true, false},
+ {Greater, false, true, false, true},
+ };
+ for (auto TC : TestCases) {
+ auto V = TC.Value;
+ assert((V == 0) == TC.ExpectEq);
+ assert((0 == V) == TC.ExpectEq);
+ assert((V != 0) == TC.ExpectNeq);
+ assert((0 != V) == TC.ExpectNeq);
+
+ assert((V < 0) == TC.ExpectLess);
+ assert((V > 0) == TC.ExpectGreater);
+ assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
+ assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
+
+ assert((0 < V) == TC.ExpectGreater);
+ assert((0 > V) == TC.ExpectLess);
+ assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
+ assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
+ }
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ {
+ std::strong_ordering res = (Eq <=> 0);
+ ((void)res);
+ res = (0 <=> Eq);
+ ((void)res);
+ }
+ enum ExpectRes {
+ ER_Greater,
+ ER_Less,
+ ER_Equiv
+ };
+ struct {
+ std::strong_ordering Value;
+ ExpectRes Expect;
+ } SpaceshipTestCases[] = {
+ {std::strong_ordering::equivalent, ER_Equiv},
+ {std::strong_ordering::less, ER_Less},
+ {std::strong_ordering::greater, ER_Greater},
+ };
+ for (auto TC : SpaceshipTestCases)
+ {
+ std::strong_ordering Res = (0 <=> TC.Value);
+ switch (TC.Expect) {
+ case ER_Equiv:
+ assert(Res == 0);
+ assert(0 == Res);
+ break;
+ case ER_Less:
+ assert(Res < 0);
+ break;
+ case ER_Greater:
+ assert(Res > 0);
+ break;
+ }
+ }
+#endif
+
+ return true;
+}
+
+int main() {
+ test_static_members();
+ test_signatures();
+ static_assert(test_conversion(), "conversion test failed");
+ static_assert(test_constexpr(), "constexpr test failed");
+}
Added: libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp (added)
+++ libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp Fri Apr 6 14:37:23 2018
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++98, c++03, c++11, c++14, c++17
+
+// <compare>
+
+// class weak_equality
+
+
+#include <compare>
+#include <cassert>
+#include "test_macros.h"
+
+const volatile void* volatile sink;
+
+void test_static_members() {
+ DoNotOptimize(&std::weak_equality::equivalent);
+ DoNotOptimize(&std::weak_equality::nonequivalent);
+}
+
+void test_signatures() {
+ auto& Eq = std::weak_equality::equivalent;
+
+ ASSERT_NOEXCEPT(Eq == 0);
+ ASSERT_NOEXCEPT(0 == Eq);
+ ASSERT_NOEXCEPT(Eq != 0);
+ ASSERT_NOEXCEPT(0 != Eq);
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ ASSERT_NOEXCEPT(0 <=> Eq);
+ ASSERT_NOEXCEPT(Eq <=> 0);
+ ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_equality);
+ ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_equality);
+#endif
+}
+
+constexpr bool test_constexpr() {
+ auto& Eq = std::weak_equality::equivalent;
+ auto& NEq = std::weak_equality::nonequivalent;
+ assert((Eq == 0) == true);
+ assert((0 == Eq) == true);
+ assert((NEq == 0) == false);
+ assert((0 == NEq) == false);
+
+ assert((Eq != 0) == false);
+ assert((0 != Eq) == false);
+ assert((NEq != 0) == true);
+ assert((0 != NEq) == true);
+
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ std::weak_equality res = (Eq <=> 0);
+ ((void)res);
+ res = (0 <=> Eq);
+ ((void)res);
+#endif
+
+ return true;
+}
+
+int main() {
+ test_static_members();
+ test_signatures();
+ static_assert(test_constexpr(), "constexpr test failed");
+}
Added: libcxx/trunk/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp?rev=329460&view=auto
==============================================================================
--- libcxx/trunk/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp (added)
+++ libcxx/trunk/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp Fri Apr 6 14:37:23 2018
@@ -0,0 +1,169 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++98, c++03, c++11, c++14, c++17
+
+// <compare>
+
+// class weak_ordering
+
+
+#include <compare>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+const volatile void* volatile sink;
+
+void test_static_members() {
+ DoNotOptimize(&std::weak_ordering::less);
+ DoNotOptimize(&std::weak_ordering::equivalent);
+ DoNotOptimize(&std::weak_ordering::greater);
+}
+
+void test_signatures() {
+ auto& Eq = std::weak_ordering::equivalent;
+
+ ASSERT_NOEXCEPT(Eq == 0);
+ ASSERT_NOEXCEPT(0 == Eq);
+ ASSERT_NOEXCEPT(Eq != 0);
+ ASSERT_NOEXCEPT(0 != Eq);
+ ASSERT_NOEXCEPT(0 < Eq);
+ ASSERT_NOEXCEPT(Eq < 0);
+ ASSERT_NOEXCEPT(0 <= Eq);
+ ASSERT_NOEXCEPT(Eq <= 0);
+ ASSERT_NOEXCEPT(0 > Eq);
+ ASSERT_NOEXCEPT(Eq > 0);
+ ASSERT_NOEXCEPT(0 >= Eq);
+ ASSERT_NOEXCEPT(Eq >= 0);
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ ASSERT_NOEXCEPT(0 <=> Eq);
+ ASSERT_NOEXCEPT(Eq <=> 0);
+ ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_ordering);
+ ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_ordering);
+#endif
+}
+
+constexpr bool test_conversion() {
+ static_assert(std::is_convertible<const std::weak_ordering&,
+ std::weak_equality>::value, "");
+ { // value == 0
+ auto V = std::weak_ordering::equivalent;
+ std::weak_equality WV = V;
+ assert(WV == 0);
+ }
+ std::weak_ordering WeakTestCases[] = {
+ std::weak_ordering::less,
+ std::weak_ordering::greater,
+ };
+ for (auto V : WeakTestCases)
+ { // value != 0
+ std::weak_equality WV = V;
+ assert(WV != 0);
+ }
+ static_assert(std::is_convertible<const std::weak_ordering&,
+ std::partial_ordering>::value, "");
+ { // value == 0
+ auto V = std::weak_ordering::equivalent;
+ std::partial_ordering WV = V;
+ assert(WV == 0);
+ }
+ { // value < 0
+ auto V = std::weak_ordering::less;
+ std::partial_ordering WV = V;
+ assert(WV < 0);
+ }
+ { // value > 0
+ auto V = std::weak_ordering::greater;
+ std::partial_ordering WV = V;
+ assert(WV > 0);
+ }
+ return true;
+}
+
+constexpr bool test_constexpr() {
+ auto& Eq = std::weak_ordering::equivalent;
+ auto& Less = std::weak_ordering::less;
+ auto& Greater = std::weak_ordering::greater;
+ struct {
+ std::weak_ordering Value;
+ bool ExpectEq;
+ bool ExpectNeq;
+ bool ExpectLess;
+ bool ExpectGreater;
+ } TestCases[] = {
+ {Eq, true, false, false, false},
+ {Less, false, true, true, false},
+ {Greater, false, true, false, true},
+ };
+ for (auto TC : TestCases) {
+ auto V = TC.Value;
+ assert((V == 0) == TC.ExpectEq);
+ assert((0 == V) == TC.ExpectEq);
+ assert((V != 0) == TC.ExpectNeq);
+ assert((0 != V) == TC.ExpectNeq);
+
+ assert((V < 0) == TC.ExpectLess);
+ assert((V > 0) == TC.ExpectGreater);
+ assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
+ assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
+
+ assert((0 < V) == TC.ExpectGreater);
+ assert((0 > V) == TC.ExpectLess);
+ assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
+ assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
+ }
+#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
+ {
+ std::weak_ordering res = (Eq <=> 0);
+ ((void)res);
+ res = (0 <=> Eq);
+ ((void)res);
+ }
+ enum ExpectRes {
+ ER_Greater,
+ ER_Less,
+ ER_Equiv
+ };
+ struct {
+ std::weak_ordering Value;
+ ExpectRes Expect;
+ } SpaceshipTestCases[] = {
+ {std::weak_ordering::equivalent, ER_Equiv},
+ {std::weak_ordering::less, ER_Less},
+ {std::weak_ordering::greater, ER_Greater},
+ };
+ for (auto TC : SpaceshipTestCases)
+ {
+ std::weak_ordering Res = (0 <=> TC.Value);
+ switch (TC.Expect) {
+ case ER_Equiv:
+ assert(Res == 0);
+ assert(0 == Res);
+ break;
+ case ER_Less:
+ assert(Res < 0);
+ break;
+ case ER_Greater:
+ assert(Res > 0);
+ break;
+ }
+ }
+#endif
+
+ return true;
+}
+
+int main() {
+ test_static_members();
+ test_signatures();
+ static_assert(test_conversion(), "conversion test failed");
+ static_assert(test_constexpr(), "constexpr test failed");
+}
Modified: libcxx/trunk/test/support/test_macros.h
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/support/test_macros.h?rev=329460&r1=329459&r2=329460&view=diff
==============================================================================
--- libcxx/trunk/test/support/test_macros.h (original)
+++ libcxx/trunk/test/support/test_macros.h Fri Apr 6 14:37:23 2018
@@ -169,6 +169,11 @@
#define TEST_SAFE_STATIC
#endif
+// FIXME: Fix this feature check when either (A) a compiler provides a complete
+// implementation, or (b) a feature check macro is specified
+#define TEST_HAS_NO_SPACESHIP_OPERATOR
+
+
#if TEST_STD_VER < 11
#define ASSERT_NOEXCEPT(...)
#define ASSERT_NOT_NOEXCEPT(...)
More information about the cfe-commits
mailing list