From: Eric Fiselier Date: Wed, 12 Oct 2016 06:48:31 +0000 (+0000) Subject: Revert Add . Will recommit with better commit message X-Git-Tag: llvmorg-4.0.0-rc1~7416 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=fc647db3ee8215ab2fa5f7cdea8d327c2faa768f;p=platform%2Fupstream%2Fllvm.git Revert Add . Will recommit with better commit message llvm-svn: 283978 --- diff --git a/libcxx/.gitignore b/libcxx/.gitignore index 49657ed..db7f90d 100644 --- a/libcxx/.gitignore +++ b/libcxx/.gitignore @@ -56,6 +56,3 @@ target/ # MSVC libraries test harness env.lst keep.lst - -# Editor by-products -.vscode/ diff --git a/libcxx/include/__config b/libcxx/include/__config index b18bd46..db55b2c 100644 --- a/libcxx/include/__config +++ b/libcxx/include/__config @@ -914,10 +914,6 @@ extern "C" void __sanitizer_annotate_contiguous_container( #define _LIBCPP_SAFE_STATIC #endif -#if !__has_builtin(__builtin_addressof) && _GNUC_VER < 700 -#define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF -#endif - #endif // __cplusplus #endif // _LIBCPP_CONFIG diff --git a/libcxx/include/optional b/libcxx/include/optional deleted file mode 100644 index 2a767f2..0000000 --- a/libcxx/include/optional +++ /dev/null @@ -1,1318 +0,0 @@ -// -*- C++ -*- -//===-------------------------- optional ----------------------------------===// -// -// 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_OPTIONAL -#define _LIBCPP_OPTIONAL - -/* - optional synopsis - -// C++1z - -namespace std { - // 20.6.3, optional for object types - template class optional; - - // 20.6.4, no-value state indicator - struct nullopt_t{see below }; - constexpr nullopt_t nullopt(unspecified ); - - // 20.6.5, class bad_optional_access - class bad_optional_access; - - // 20.6.6, relational operators - template - constexpr bool operator==(const optional&, const optional&); - template - constexpr bool operator!=(const optional&, const optional&); - template - constexpr bool operator<(const optional&, const optional&); - template - constexpr bool operator>(const optional&, const optional&); - template - constexpr bool operator<=(const optional&, const optional&); - template - constexpr bool operator>=(const optional&, const optional&); - template constexpr bool operator==(const optional&, nullopt_t) noexcept; - template constexpr bool operator==(nullopt_t, const optional&) noexcept; - template constexpr bool operator!=(const optional&, nullopt_t) noexcept; - template constexpr bool operator!=(nullopt_t, const optional&) noexcept; - template constexpr bool operator<(const optional&, nullopt_t) noexcept; - template constexpr bool operator<(nullopt_t, const optional&) noexcept; - template constexpr bool operator<=(const optional&, nullopt_t) noexcept; - template constexpr bool operator<=(nullopt_t, const optional&) noexcept; - template constexpr bool operator>(const optional&, nullopt_t) noexcept; - template constexpr bool operator>(nullopt_t, const optional&) noexcept; - template constexpr bool operator>=(const optional&, nullopt_t) noexcept; - template constexpr bool operator>=(nullopt_t, const optional&) noexcept; - - // 20.6.8, comparison with T - template constexpr bool operator==(const optional&, const T&); - template constexpr bool operator==(const T&, const optional&); - template constexpr bool operator!=(const optional&, const T&); - template constexpr bool operator!=(const T&, const optional&); - template constexpr bool operator<(const optional&, const T&); - template constexpr bool operator<(const T&, const optional&); - template constexpr bool operator<=(const optional&, const T&); - template constexpr bool operator<=(const T&, const optional&); - template constexpr bool operator>(const optional&, const T&); - template constexpr bool operator>(const T&, const optional&); - template constexpr bool operator>=(const optional&, const T&); - template constexpr bool operator>=(const T&, const optional&); - - // 20.6.9, specialized algorithms - template void swap(optional&, optional&) noexcept(see below ); - template constexpr optional make_optional(T&&); - template - constexpr optional make_optional(Args&&... args); - template - constexpr optional make_optional(initializer_list il, Args&&... args); - - // 20.6.10, hash support - template struct hash; - template struct hash>; - - template class optional { - public: - using value_type = T; - - // 20.6.3.1, constructors - constexpr optional() noexcept; - constexpr optional(nullopt_t) noexcept; - optional(const optional &); - optional(optional &&) noexcept(see below ); - template constexpr explicit optional(in_place_t, Args &&...); - template - constexpr explicit optional(in_place_t, initializer_list, Args &&...); - template - constexpr EXPLICIT optional(U &&); - template - constexpr EXPLICIT optional(const optional &); - template - constexpr EXPLICIT optional(optional &&); - - // 20.6.3.2, destructor - ~optional(); - - // 20.6.3.3, assignment - optional &operator=(nullopt_t) noexcept; - optional &operator=(const optional &); - optional &operator=(optional &&) noexcept(see below ); - template optional &operator=(U &&); - template optional &operator=(const optional &); - template optional &operator=(optional &&); - template void emplace(Args &&...); - template - void emplace(initializer_list, Args &&...); - - // 20.6.3.4, swap - void swap(optional &) noexcept(see below ); - - // 20.6.3.5, observers - constexpr T const *operator->() const; - constexpr T *operator->(); - constexpr T const &operator*() const &; - constexpr T &operator*() &; - constexpr T &&operator*() &&; - constexpr const T &&operator*() const &&; - constexpr explicit operator bool() const noexcept; - constexpr bool has_value() const noexcept; - constexpr T const &value() const &; - constexpr T &value() &; - constexpr T &&value() &&; - constexpr const T &&value() const &&; - template constexpr T value_or(U &&) const &; - template constexpr T value_or(U &&) &&; - - // 20.6.3.6, modifiers - void reset() noexcept; - - private: - T *val; // exposition only - }; -} // namespace std - -*/ - -#include <__config> -#include <__debug> -#include <__functional_base> -#include <__undef_min_max> -#include -#include -#include -#include -#include -#include - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -namespace std // purposefully not using versioning namespace -{ - -class _LIBCPP_EXCEPTION_ABI bad_optional_access - : public logic_error -{ -public: - _LIBCPP_INLINE_VISIBILITY - bad_optional_access() : logic_error("bad optional access") {} - - // Get the key function ~bad_optional_access() into the dylib - _LIBCPP_FUNC_VIS - virtual ~bad_optional_access() _NOEXCEPT; -}; - -} // std - -#if _LIBCPP_STD_VER > 14 - -_LIBCPP_BEGIN_NAMESPACE_STD - -_LIBCPP_NORETURN -inline _LIBCPP_INLINE_VISIBILITY -void __throw_bad_optional_access() { -#ifndef _LIBCPP_NO_EXCEPTIONS - throw bad_optional_access(); -#else - _VSTD::abort(); -#endif -} - -struct nullopt_t -{ - struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; }; - _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {} -}; - -/* inline */ constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}}; - -template ::value> -struct __optional_destruct_base; - -template -struct __optional_destruct_base<_Tp, false> -{ - typedef _Tp value_type; - static_assert(is_object_v, - "instantiation of optional with a non-object type is undefined behavior"); - union - { - char __null_state_; - value_type __val_; - }; - bool __engaged_; - - _LIBCPP_INLINE_VISIBILITY - ~__optional_destruct_base() - { - if (__engaged_) - __val_.~value_type(); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr __optional_destruct_base() noexcept - : __null_state_(), - __engaged_(false) {} - - template - _LIBCPP_INLINE_VISIBILITY - constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) - : __val_(_VSTD::forward<_Args>(__args)...), - __engaged_(true) {} - - _LIBCPP_INLINE_VISIBILITY - void reset() noexcept - { - if (__engaged_) - { - __val_.~value_type(); - __engaged_ = false; - } - } -}; - -template -struct __optional_destruct_base<_Tp, true> -{ - typedef _Tp value_type; - static_assert(is_object_v, - "instantiation of optional with a non-object type is undefined behavior"); - union - { - char __null_state_; - value_type __val_; - }; - bool __engaged_; - - _LIBCPP_INLINE_VISIBILITY - constexpr __optional_destruct_base() noexcept - : __null_state_(), - __engaged_(false) {} - - template - _LIBCPP_INLINE_VISIBILITY - constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) - : __val_(_VSTD::forward<_Args>(__args)...), - __engaged_(true) {} - - _LIBCPP_INLINE_VISIBILITY - void reset() noexcept - { - if (__engaged_) - { - __engaged_ = false; - } - } -}; - -template ::value> -struct __optional_storage_base : __optional_destruct_base<_Tp> -{ - using __base = __optional_destruct_base<_Tp>; - using value_type = _Tp; - using __base::__base; - - _LIBCPP_INLINE_VISIBILITY - constexpr bool has_value() const noexcept - { - return this->__engaged_; - } - - _LIBCPP_INLINE_VISIBILITY - constexpr value_type& __get() & noexcept - { - return this->__val_; - } - _LIBCPP_INLINE_VISIBILITY - constexpr const value_type& __get() const& noexcept - { - return this->__val_; - } - _LIBCPP_INLINE_VISIBILITY - constexpr value_type&& __get() && noexcept - { - return _VSTD::move(this->__val_); - } - _LIBCPP_INLINE_VISIBILITY - constexpr const value_type&& __get() const&& noexcept - { - return _VSTD::move(this->__val_); - } - - template - _LIBCPP_INLINE_VISIBILITY - void __construct(_Args&&... __args) - { - _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); - ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); - this->__engaged_ = true; - } - - template - _LIBCPP_INLINE_VISIBILITY - void __construct_from(_That&& __opt) - { - if (__opt.has_value()) - __construct(_VSTD::forward<_That>(__opt).__get()); - } - - template - _LIBCPP_INLINE_VISIBILITY - void __assign_from(_That&& __opt) - { - if (this->__engaged_ == __opt.has_value()) - { - if (this->__engaged_) - this->__val_ = _VSTD::forward<_That>(__opt).__get(); - } - else - { - if (this->__engaged_) - this->reset(); - else - __construct(_VSTD::forward<_That>(__opt).__get()); - } - } -}; - -// optional is currently required ill-formed, however it may to be in the -// future. For this reason it has already been implemented to ensure we can -// make the change in an ABI compatible manner. -template -struct __optional_storage_base<_Tp, true> -{ - using value_type = _Tp; - using __raw_type = remove_reference_t<_Tp>; - __raw_type* __value_; - - template - static constexpr bool __can_bind_reference() { - using _RawUp = typename remove_reference<_Up>::type; - using _UpPtr = _RawUp*; - using _RawTp = typename remove_reference<_Tp>::type; - using _TpPtr = _RawTp*; - using _CheckLValueArg = integral_constant::value && is_convertible<_UpPtr, _TpPtr>::value) - || is_same<_RawUp, reference_wrapper<_RawTp>>::value - || is_same<_RawUp, reference_wrapper::type>>::value - >; - return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) - || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value && - is_convertible<_UpPtr, _TpPtr>::value); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr __optional_storage_base() noexcept - : __value_(nullptr) {} - - template - _LIBCPP_INLINE_VISIBILITY - constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) - : __value_(_VSTD::addressof(__uarg)) - { - static_assert(__can_bind_reference<_UArg>(), - "Attempted to construct a reference element in tuple from a " - "possible temporary"); - } - - _LIBCPP_INLINE_VISIBILITY - void reset() noexcept { __value_ = nullptr; } - - _LIBCPP_INLINE_VISIBILITY - constexpr bool has_value() const noexcept - { return __value_ != nullptr; } - - _LIBCPP_INLINE_VISIBILITY - constexpr value_type& __get() const& noexcept - { return *__value_; } - - _LIBCPP_INLINE_VISIBILITY - constexpr value_type&& __get() const&& noexcept - { return _VSTD::forward(*__value_); } - - template - _LIBCPP_INLINE_VISIBILITY - void __construct(_UArg&& __val) - { - _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); - static_assert(__can_bind_reference<_UArg>(), - "Attempted to construct a reference element in tuple from a " - "possible temporary"); - __value_ = _VSTD::addressof(__val); - } - - template - _LIBCPP_INLINE_VISIBILITY - void __construct_from(_That&& __opt) - { - if (__opt.has_value()) - __construct(_VSTD::forward<_That>(__opt).__get()); - } - - template - _LIBCPP_INLINE_VISIBILITY - void __assign_from(_That&& __opt) - { - if (has_value() == __opt.has_value()) - { - if (has_value()) - *__value_ = _VSTD::forward<_That>(__opt).__get(); - } - else - { - if (has_value()) - reset(); - else - __construct(_VSTD::forward<_That>(__opt).__get()); - } - } -}; - -template ::value> -struct __optional_storage; - -template -struct __optional_storage<_Tp, true> : __optional_storage_base<_Tp> -{ - using __optional_storage_base<_Tp>::__optional_storage_base; -}; - -template -struct __optional_storage<_Tp, false> : __optional_storage_base<_Tp> -{ - using value_type = _Tp; - using __optional_storage_base<_Tp>::__optional_storage_base; - - _LIBCPP_INLINE_VISIBILITY - __optional_storage() = default; - - _LIBCPP_INLINE_VISIBILITY - __optional_storage(const __optional_storage& __opt) - { - this->__construct_from(__opt); - } - - _LIBCPP_INLINE_VISIBILITY - __optional_storage(__optional_storage&& __opt) - noexcept(is_nothrow_move_constructible_v) - { - this->__construct_from(_VSTD::move(__opt)); - } - - _LIBCPP_INLINE_VISIBILITY - __optional_storage& operator=(const __optional_storage& __opt) - { - this->__assign_from(__opt); - return *this; - } - - _LIBCPP_INLINE_VISIBILITY - __optional_storage& operator=(__optional_storage&& __opt) - noexcept(is_nothrow_move_assignable_v && - is_nothrow_move_constructible_v) - { - this->__assign_from(_VSTD::move(__opt)); - return *this; - } -}; - -template -using __optional_sfinae_ctor_base_t = __sfinae_ctor_base< - is_copy_constructible<_Tp>::value, - is_move_constructible<_Tp>::value ->; - -template -using __optional_sfinae_assign_base_t = __sfinae_assign_base< - (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value), - (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) || - (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value) ->; - -template -class optional - : private __optional_storage<_Tp> - , private __optional_sfinae_ctor_base_t<_Tp> - , private __optional_sfinae_assign_base_t<_Tp> -{ - using __base = __optional_storage<_Tp>; -public: - using value_type = _Tp; - -private: - // Disable the reference extension using this static assert. - static_assert(!is_same_v, - "instantiation of optional with in_place_t is ill-formed"); - static_assert(!is_same_v<__uncvref_t, nullopt_t>, - "instantiation of optional with nullopt_t is ill-formed"); - static_assert(!is_reference_v, - "instantiation of optional with a reference type is ill-formed"); - static_assert(is_destructible_v, - "instantiation of optional with a non-destructible type is ill-formed"); - - // LWG2756: conditionally explicit conversion from _Up - struct _CheckOptionalArgsConstructor { - template - static constexpr bool __enable_implicit() { - return is_constructible_v<_Tp, _Up&&> && - is_convertible_v<_Up&&, _Tp>; - } - - template - static constexpr bool __enable_explicit() { - return is_constructible_v<_Tp, _Up&&> && - !is_convertible_v<_Up&&, _Tp>; - } - }; - template - using _CheckOptionalArgsCtor = conditional_t< - !is_same_v && - !is_same_v, optional>, - _CheckOptionalArgsConstructor, - __check_tuple_constructor_fail - >; - template - struct _CheckOptionalLikeConstructor { - template > - using __check_constructible_from_opt = __lazy_or< - is_constructible<_Tp, _Opt&>, - is_constructible<_Tp, _Opt const&>, - is_constructible<_Tp, _Opt&&>, - is_constructible<_Tp, _Opt const&&>, - is_convertible<_Opt&, _Tp>, - is_convertible<_Opt const&, _Tp>, - is_convertible<_Opt&&, _Tp>, - is_convertible<_Opt const&&, _Tp> - >; - template > - using __check_assignable_from_opt = __lazy_or< - is_assignable<_Tp&, _Opt&>, - is_assignable<_Tp&, _Opt const&>, - is_assignable<_Tp&, _Opt&&>, - is_assignable<_Tp&, _Opt const&&> - >; - template - static constexpr bool __enable_implicit() { - return is_convertible<_QUp, _Tp>::value && - !__check_constructible_from_opt<_Up>::value; - } - template - static constexpr bool __enable_explicit() { - return !is_convertible<_QUp, _Tp>::value && - !__check_constructible_from_opt<_Up>::value; - } - template - static constexpr bool __enable_assign() { - // Construction and assignability of _Qup to _Tp has already been - // checked. - return !__check_constructible_from_opt<_Up>::value && - !__check_assignable_from_opt<_Up>::value; - } - }; - - template - using _CheckOptionalLikeCtor = conditional_t< - __lazy_and< - __lazy_not>, - is_constructible<_Tp, _QualUp> - >::value, - _CheckOptionalLikeConstructor<_QualUp>, - __check_tuple_constructor_fail - >; - template - using _CheckOptionalLikeAssign = conditional_t< - __lazy_and< - __lazy_not>, - is_constructible<_Tp, _QualUp>, - is_assignable<_Tp&, _QualUp> - >::value, - _CheckOptionalLikeConstructor<_QualUp>, - __check_tuple_constructor_fail - >; -public: - - _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} - _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default; - _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default; - _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} - - template > - > - _LIBCPP_INLINE_VISIBILITY - constexpr explicit optional(in_place_t, _Args&&... __args) - : __base(in_place, _VSTD::forward<_Args>(__args)...) {} - - template &, _Args...>> - > - _LIBCPP_INLINE_VISIBILITY - constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) - : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} - - template ::template __enable_implicit<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - constexpr optional(_Up&& __v) - : __base(in_place, _VSTD::forward<_Up>(__v)) {} - - template ::template __enable_explicit<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - constexpr explicit optional(_Up&& __v) - : __base(in_place, _VSTD::forward<_Up>(__v)) {} - - // LWG2756: conditionally explicit conversion from const optional<_Up>& - template ::template __enable_implicit<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - optional(const optional<_Up>& __v) - { - this->__construct_from(__v); - } - template ::template __enable_explicit<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - explicit optional(const optional<_Up>& __v) - { - this->__construct_from(__v); - } - - // LWG2756: conditionally explicit conversion from optional<_Up>&& - template ::template __enable_implicit<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - optional(optional<_Up>&& __v) - { - this->__construct_from(_VSTD::move(__v)); - } - template ::template __enable_explicit<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - explicit optional(optional<_Up>&& __v) - { - this->__construct_from(_VSTD::move(__v)); - } - - _LIBCPP_INLINE_VISIBILITY - optional& operator=(nullopt_t) noexcept - { - reset(); - return *this; - } - - _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default; - _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default; - - // LWG2756 - template && - !(is_same_v<_Up, value_type> && is_scalar_v) && - is_constructible_v && - is_assignable_v - > - > - _LIBCPP_INLINE_VISIBILITY - optional& - operator=(_Up&& __v) - { - if (this->has_value()) - this->__get() = _VSTD::forward<_Up>(__v); - else - this->__construct(_VSTD::forward<_Up>(__v)); - return *this; - } - - // LWG2756 - template ::template __enable_assign<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - optional& - operator=(const optional<_Up>& __v) - { - this->__assign_from(__v); - return *this; - } - - // LWG2756 - template ::template __enable_assign<_Up>() - , int> = 0> - _LIBCPP_INLINE_VISIBILITY - optional& - operator=(optional<_Up>&& __v) - { - this->__assign_from(_VSTD::move(__v)); - return *this; - } - - template - > - > - _LIBCPP_INLINE_VISIBILITY - void - emplace(_Args&&... __args) - { - reset(); - this->__construct(_VSTD::forward<_Args>(__args)...); - } - - template &, _Args...> - > - > - _LIBCPP_INLINE_VISIBILITY - void - emplace(initializer_list<_Up> __il, _Args&&... __args) - { - reset(); - this->__construct(__il, _VSTD::forward<_Args>(__args)...); - } - - template , _Dummy>::value && - __dependent_type, _Dummy>::value - >> - _LIBCPP_INLINE_VISIBILITY - void swap(optional& __opt) - noexcept(is_nothrow_move_constructible_v && - is_nothrow_swappable_v) - { - if (this->has_value() == __opt.has_value()) - { - using _VSTD::swap; - if (this->has_value()) - swap(this->__get(), __opt.__get()); - } - else - { - if (this->has_value()) - { - __opt.__construct(_VSTD::move(this->__get())); - reset(); - } - else - { - this->__construct(_VSTD::move(__opt.__get())); - __opt.reset(); - } - } - } - - _LIBCPP_INLINE_VISIBILITY - constexpr - add_pointer_t - operator->() const - { - _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); -#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF - return _VSTD::addressof(this->__get()); -#else - return __operator_arrow(__has_operator_addressof{}, this->__get()); -#endif - } - - _LIBCPP_INLINE_VISIBILITY - constexpr - add_pointer_t - operator->() - { - _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); -#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF - return _VSTD::addressof(this->__get()); -#else - return __operator_arrow(__has_operator_addressof{}, this->__get()); -#endif - } - - _LIBCPP_INLINE_VISIBILITY - constexpr - const value_type& - operator*() const& - { - _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); - return this->__get(); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr - value_type& - operator*() & - { - _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); - return this->__get(); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr - value_type&& - operator*() && - { - _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); - return _VSTD::move(this->__get()); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr - const value_type&& - operator*() const&& - { - _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); - return _VSTD::move(this->__get()); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr explicit operator bool() const noexcept { return has_value(); } - - using __base::has_value; - using __base::__get; - - _LIBCPP_INLINE_VISIBILITY - constexpr value_type const& value() const& - { - if (!this->has_value()) - __throw_bad_optional_access(); - return this->__get(); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr value_type& value() & - { - if (!this->has_value()) - __throw_bad_optional_access(); - return this->__get(); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr value_type&& value() && - { - if (!this->has_value()) - __throw_bad_optional_access(); - return _VSTD::move(this->__get()); - } - - _LIBCPP_INLINE_VISIBILITY - constexpr value_type const&& value() const&& - { - if (!this->has_value()) - __throw_bad_optional_access(); - return _VSTD::move(this->__get()); - } - - template - _LIBCPP_INLINE_VISIBILITY - constexpr value_type value_or(_Up&& __v) const& - { - static_assert(is_copy_constructible_v, - "optional::value_or: T must be copy constructible"); - static_assert(is_convertible_v<_Up, value_type>, - "optional::value_or: U must be convertible to T"); - return this->has_value() ? this->__get() : - static_cast(_VSTD::forward<_Up>(__v)); - } - - template - _LIBCPP_INLINE_VISIBILITY - value_type value_or(_Up&& __v) && - { - static_assert(is_move_constructible_v, - "optional::value_or: T must be move constructible"); - static_assert(is_convertible_v<_Up, value_type>, - "optional::value_or: U must be convertible to T"); - return this->has_value() ? _VSTD::move(this->__get()) : - static_cast(_VSTD::forward<_Up>(__v)); - } - - using __base::reset; - -private: - template - _LIBCPP_INLINE_VISIBILITY - static _Up* - __operator_arrow(true_type, _Up& __x) - { - return _VSTD::addressof(__x); - } - - template - _LIBCPP_INLINE_VISIBILITY - static constexpr _Up* - __operator_arrow(false_type, _Up& __x) - { - return &__x; - } -}; - -// Comparisons between optionals -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() == - _VSTD::declval()), bool>, - bool -> -operator==(const optional<_Tp>& __x, const optional<_Tp>& __y) -{ - if (static_cast(__x) != static_cast(__y)) - return false; - if (!static_cast(__x)) - return true; - return *__x == *__y; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() != - _VSTD::declval()), bool>, - bool -> -operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y) -{ - if (static_cast(__x) != static_cast(__y)) - return true; - if (!static_cast(__x)) - return false; - return *__x != *__y; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() < - _VSTD::declval()), bool>, - bool -> -operator<(const optional<_Tp>& __x, const optional<_Tp>& __y) -{ - if (!static_cast(__y)) - return false; - if (!static_cast(__x)) - return true; - return *__x < *__y; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() > - _VSTD::declval()), bool>, - bool -> -operator>(const optional<_Tp>& __x, const optional<_Tp>& __y) -{ - if (!static_cast(__x)) - return false; - if (!static_cast(__y)) - return true; - return *__x > *__y; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() <= - _VSTD::declval()), bool>, - bool -> -operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y) -{ - if (!static_cast(__x)) - return true; - if (!static_cast(__y)) - return false; - return *__x <= *__y; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() >= - _VSTD::declval()), bool>, - bool -> -operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y) -{ - if (!static_cast(__y)) - return true; - if (!static_cast(__x)) - return false; - return *__x >= *__y; -} - -// Comparisons with nullopt -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator==(const optional<_Tp>& __x, nullopt_t) noexcept -{ - return !static_cast(__x); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator==(nullopt_t, const optional<_Tp>& __x) noexcept -{ - return !static_cast(__x); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator!=(const optional<_Tp>& __x, nullopt_t) noexcept -{ - return static_cast(__x); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator!=(nullopt_t, const optional<_Tp>& __x) noexcept -{ - return static_cast(__x); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator<(const optional<_Tp>&, nullopt_t) noexcept -{ - return false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator<(nullopt_t, const optional<_Tp>& __x) noexcept -{ - return static_cast(__x); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator<=(const optional<_Tp>& __x, nullopt_t) noexcept -{ - return !static_cast(__x); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator<=(nullopt_t, const optional<_Tp>& __x) noexcept -{ - return true; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator>(const optional<_Tp>& __x, nullopt_t) noexcept -{ - return static_cast(__x); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator>(nullopt_t, const optional<_Tp>& __x) noexcept -{ - return false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator>=(const optional<_Tp>&, nullopt_t) noexcept -{ - return true; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -bool -operator>=(nullopt_t, const optional<_Tp>& __x) noexcept -{ - return !static_cast(__x); -} - -// Comparisons with T -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() == - _VSTD::declval()), bool>, - bool -> -operator==(const optional<_Tp>& __x, const _Tp& __v) -{ - return static_cast(__x) ? *__x == __v : false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() == - _VSTD::declval()), bool>, - bool -> -operator==(const _Tp& __v, const optional<_Tp>& __x) -{ - return static_cast(__x) ? __v == *__x : false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() != - _VSTD::declval()), bool>, - bool -> -operator!=(const optional<_Tp>& __x, const _Tp& __v) -{ - return static_cast(__x) ? *__x != __v : true; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() != - _VSTD::declval()), bool>, - bool -> -operator!=(const _Tp& __v, const optional<_Tp>& __x) -{ - return static_cast(__x) ? __v != *__x : true; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() < - _VSTD::declval()), bool>, - bool -> -operator<(const optional<_Tp>& __x, const _Tp& __v) -{ - return static_cast(__x) ? *__x < __v : true; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() < - _VSTD::declval()), bool>, - bool -> -operator<(const _Tp& __v, const optional<_Tp>& __x) -{ - return static_cast(__x) ? __v < *__x : false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() <= - _VSTD::declval()), bool>, - bool -> -operator<=(const optional<_Tp>& __x, const _Tp& __v) -{ - return static_cast(__x) ? *__x <= __v : true; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() <= - _VSTD::declval()), bool>, - bool -> -operator<=(const _Tp& __v, const optional<_Tp>& __x) -{ - return static_cast(__x) ? __v <= *__x : false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() > - _VSTD::declval()), bool>, - bool -> -operator>(const optional<_Tp>& __x, const _Tp& __v) -{ - return static_cast(__x) ? *__x > __v : false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() > - _VSTD::declval()), bool>, - bool -> -operator>(const _Tp& __v, const optional<_Tp>& __x) -{ - return static_cast(__x) ? __v > *__x : true; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() >= - _VSTD::declval()), bool>, - bool -> -operator>=(const optional<_Tp>& __x, const _Tp& __v) -{ - return static_cast(__x) ? *__x >= __v : false; -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -enable_if_t< - is_convertible_v() >= - _VSTD::declval()), bool>, - bool -> -operator>=(const _Tp& __v, const optional<_Tp>& __x) -{ - return static_cast(__x) ? __v >= *__x : true; -} - - -template -inline _LIBCPP_INLINE_VISIBILITY -enable_if_t< - is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, - void -> -swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) -{ - __x.swap(__y); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -optional> make_optional(_Tp&& __v) -{ - return optional>(_VSTD::forward<_Tp>(__v)); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -optional<_Tp> make_optional(_Args&&... __args) -{ - return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...); -} - -template -_LIBCPP_INLINE_VISIBILITY constexpr -optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) -{ - return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...); -} - -template -struct _LIBCPP_TYPE_VIS_ONLY hash > -{ - typedef optional<_Tp> argument_type; - typedef size_t result_type; - - _LIBCPP_INLINE_VISIBILITY - result_type operator()(const argument_type& __opt) const _NOEXCEPT - { - return static_cast(__opt) ? hash<_Tp>()(*__opt) : 0; - } -}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_STD_VER > 14 - -#endif // _LIBCPP_OPTIONAL diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits index 43687a7..06ee3e7 100644 --- a/libcxx/include/type_traits +++ b/libcxx/include/type_traits @@ -425,7 +425,7 @@ template using enable_if_t = typename enable_if<_Bp #endif // addressof -#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF +#if __has_builtin(__builtin_addressof) || _GNUC_VER >= 700 template inline _LIBCPP_CONSTEXPR_AFTER_CXX14 @@ -446,7 +446,7 @@ addressof(_Tp& __x) _NOEXCEPT return (_Tp*)&reinterpret_cast(__x); } -#endif // _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF +#endif // __has_builtin(__builtin_addressof) #if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) // Objective-C++ Automatic Reference Counting uses qualified pointers diff --git a/libcxx/src/optional.cpp b/libcxx/src/optional.cpp index f2fbfdfe..8c5dd76 100644 --- a/libcxx/src/optional.cpp +++ b/libcxx/src/optional.cpp @@ -7,18 +7,18 @@ // //===----------------------------------------------------------------------===// -#include "optional" #include "experimental/optional" -namespace std -{ +_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL -bad_optional_access::~bad_optional_access() _NOEXCEPT = default; +#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS -} // std +bad_optional_access::~bad_optional_access() _NOEXCEPT {} -_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL +#else bad_optional_access::~bad_optional_access() _NOEXCEPT = default; +#endif + _LIBCPP_END_NAMESPACE_EXPERIMENTAL diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp deleted file mode 100644 index e4de92f..0000000 --- a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp +++ /dev/null @@ -1,81 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 -// XFAIL: libcpp-no-exceptions -// - -// optional& operator=(const optional& rhs); - -#include -#include -#include - -using std::optional; - -struct X {}; - -struct Y -{ - Y() = default; - Y& operator=(const Y&) { return *this; } -}; - -struct Z1 -{ - Z1() = default; - Z1(Z1&&) = default; - Z1(const Z1&) = default; - Z1& operator=(Z1&&) = default; - Z1& operator=(const Z1&) = delete; -}; - -struct Z2 -{ - Z2() = default; - Z2(Z2&&) = default; - Z2(const Z2&) = delete; - Z2& operator=(Z2&&) = default; - Z2& operator=(const Z2&) = default; -}; - -#if __cplusplus >= 201402 -template -constexpr bool -test() -{ - optional opt; - optional opt2; - opt = opt2; - return true; -} -#endif - -int main() -{ - { - using T = int; - static_assert((std::is_trivially_copy_assignable>::value), ""); -#if __cplusplus >= 201402 - static_assert(test(), ""); -#endif - } - { - using T = X; - static_assert((std::is_trivially_copy_assignable>::value), ""); -#if __cplusplus >= 201402 - static_assert(test(), ""); -#endif - } - static_assert(!(std::is_trivially_copy_assignable>::value), ""); - static_assert(!(std::is_trivially_copy_assignable>::value), ""); - - static_assert(!(std::is_copy_assignable>::value), ""); - static_assert(!(std::is_copy_assignable>::value), ""); -} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp deleted file mode 100644 index e2eaa8c..0000000 --- a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp +++ /dev/null @@ -1,78 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 -// XFAIL: libcpp-no-exceptions -// - -// optional& operator=(optional&& rhs); - -#include -#include -#include -#include - -using std::optional; - -struct X {}; - -struct Y -{ - Y() = default; - Y& operator=(Y&&) { return *this; } -}; - -struct Z1 -{ - Z1() = default; - Z1(Z1&&) = default; - Z1& operator=(Z1&&) = delete; -}; - -struct Z2 -{ - Z2() = default; - Z2(Z2&&) = delete; - Z2& operator=(Z2&&) = default; -}; - -#if __cplusplus >= 201402 -template -constexpr bool -test() -{ - optional opt; - optional opt2; - opt = std::move(opt2); - return true; -} -#endif - -int main() -{ - { - using T = int; - static_assert((std::is_trivially_copy_constructible>::value), ""); -#if __cplusplus >= 201402 - static_assert(test(), ""); -#endif - } - { - using T = X; - static_assert((std::is_trivially_copy_constructible>::value), ""); -#if __cplusplus >= 201402 - static_assert(test(), ""); -#endif - } - static_assert(!(std::is_trivially_move_assignable>::value), ""); - static_assert(!(std::is_trivially_move_assignable>::value), ""); - - static_assert(!(std::is_move_assignable>::value), ""); - static_assert(!(std::is_move_assignable>::value), ""); -} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp deleted file mode 100644 index 75e7635..0000000 --- a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp +++ /dev/null @@ -1,59 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 -// XFAIL: libcpp-no-exceptions -// - -// optional(const optional& rhs); - -#include -#include -#include - -using std::optional; - -struct X {}; - -struct Y -{ - Y() = default; - Y(const Y&) {} -}; - -struct Z -{ - Z() = default; - Z(Z&&) = delete; - Z(const Z&) = delete; - Z& operator=(Z&&) = delete; - Z& operator=(const Z&) = delete; -}; - -int main() -{ - { - using T = int; - static_assert((std::is_trivially_copy_constructible>::value), ""); - constexpr optional opt; - constexpr optional opt2 = opt; - (void)opt2; - } - { - using T = X; - static_assert((std::is_trivially_copy_constructible>::value), ""); - constexpr optional opt; - constexpr optional opt2 = opt; - (void)opt2; - } - static_assert(!(std::is_trivially_copy_constructible>::value), ""); - static_assert(!(std::is_trivially_copy_constructible>::value), ""); - - static_assert(!(std::is_copy_constructible>::value), ""); -} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp deleted file mode 100644 index e6d9bb8..0000000 --- a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp +++ /dev/null @@ -1,60 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 -// XFAIL: libcpp-no-exceptions -// - -// optional(optional&& rhs); - -#include -#include -#include -#include - -using std::optional; - -struct X {}; - -struct Y -{ - Y() = default; - Y(Y&&) {} -}; - -struct Z -{ - Z() = default; - Z(Z&&) = delete; - Z(const Z&) = delete; - Z& operator=(Z&&) = delete; - Z& operator=(const Z&) = delete; -}; - -int main() -{ - { - using T = int; - static_assert((std::is_trivially_copy_constructible>::value), ""); - constexpr optional opt; - constexpr optional opt2 = std::move(opt); - (void)opt2; - } - { - using T = X; - static_assert((std::is_trivially_copy_constructible>::value), ""); - constexpr optional opt; - constexpr optional opt2 = std::move(opt); - (void)opt2; - } - static_assert(!(std::is_trivially_move_constructible>::value), ""); - static_assert(!(std::is_trivially_move_constructible>::value), ""); - - static_assert(!(std::is_move_constructible>::value), ""); -} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp deleted file mode 100644 index 9493d6b..0000000 --- a/libcxx/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp +++ /dev/null @@ -1,66 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 -// - - -#include -#include -#include - -#include "archetypes.hpp" - -template -struct SpecialMemberTest { - using O = std::optional; - - template