Update to current libcxx.

This doesn't work yet as it needs to be customized for use with
emscripten still.

1 files changed, 517 insertions, 527 deletions

diff --git a/system/include/libcxx/future b/system/include/libcxx/future
index 62529d97..fa605e7d 100644
--- a/system/include/libcxx/future
+++ b/system/include/libcxx/future
@@ -40,10 +40,10 @@ enum class future_status
 };
 
 template <> struct is_error_code_enum<future_errc> : public true_type { };
-error_code make_error_code(future_errc e);
-error_condition make_error_condition(future_errc e);
+error_code make_error_code(future_errc e) noexcept;
+error_condition make_error_condition(future_errc e) noexcept;
 
-const error_category& future_category();
+const error_category& future_category() noexcept;
 
 class future_error
     : public logic_error
@@ -51,8 +51,8 @@ class future_error
 public:
     future_error(error_code ec);  // exposition only
 
-    const error_code& code() const throw();
-    const char*       what() const throw();
+    const error_code& code() const noexcept;
+    const char*       what() const noexcept;
 };
 
 template <class R>
@@ -62,14 +62,14 @@ public:
     promise();
     template <class Allocator>
         promise(allocator_arg_t, const Allocator& a);
-    promise(promise&& rhs);
+    promise(promise&& rhs) noexcept;
     promise(const promise& rhs) = delete;
     ~promise();
 
     // assignment
-    promise& operator=(promise&& rhs);
+    promise& operator=(promise&& rhs) noexcept;
     promise& operator=(const promise& rhs) = delete;
-    void swap(promise& other);
+    void swap(promise& other) noexcept;
 
     // retrieving the result
     future<R> get_future();
@@ -92,14 +92,14 @@ public:
     promise();
     template <class Allocator>
         promise(allocator_arg_t, const Allocator& a);
-    promise(promise&& rhs);
+    promise(promise&& rhs) noexcept;
     promise(const promise& rhs) = delete;
     ~promise();
 
     // assignment
-    promise& operator=(promise&& rhs);
+    promise& operator=(promise&& rhs) noexcept;
     promise& operator=(const promise& rhs) = delete;
-    void swap(promise& other);
+    void swap(promise& other) noexcept;
 
     // retrieving the result
     future<R&> get_future();
@@ -120,14 +120,14 @@ public:
     promise();
     template <class Allocator>
         promise(allocator_arg_t, const Allocator& a);
-    promise(promise&& rhs);
+    promise(promise&& rhs) noexcept;
     promise(const promise& rhs) = delete;
     ~promise();
 
     // assignment
-    promise& operator=(promise&& rhs);
+    promise& operator=(promise&& rhs) noexcept;
     promise& operator=(const promise& rhs) = delete;
-    void swap(promise& other);
+    void swap(promise& other) noexcept;
 
     // retrieving the result
     future<void> get_future();
@@ -141,7 +141,7 @@ public:
     void set_exception_at_thread_exit(exception_ptr p);
 };
 
-template <class R> void swap(promise<R>& x, promise<R>& y);
+template <class R> void swap(promise<R>& x, promise<R>& y) noexcept;
 
 template <class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc> : public true_type {};
@@ -150,19 +150,19 @@ template <class R>
 class future
 {
 public:
-    future();
-    future(future&&);
+    future() noexcept;
+    future(future&&) noexcept;
     future(const future& rhs) = delete;
     ~future();
     future& operator=(const future& rhs) = delete;
-    future& operator=(future&&);
-    shared_future<R> share() &&;
+    future& operator=(future&&) noexcept;
+    shared_future<R> share();
 
     // retrieving the value
     R get();
 
     // functions to check state
-    bool valid() const;
+    bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
@@ -177,19 +177,19 @@ template <class R>
 class future<R&>
 {
 public:
-    future();
-    future(future&&);
+    future() noexcept;
+    future(future&&) noexcept;
     future(const future& rhs) = delete;
     ~future();
     future& operator=(const future& rhs) = delete;
-    future& operator=(future&&);
-    shared_future<R&> share() &&;
+    future& operator=(future&&) noexcept;
+    shared_future<R&> share();
 
     // retrieving the value
     R& get();
 
     // functions to check state
-    bool valid() const;
+    bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
@@ -204,19 +204,19 @@ template <>
 class future<void>
 {
 public:
-    future();
-    future(future&&);
+    future() noexcept;
+    future(future&&) noexcept;
     future(const future& rhs) = delete;
     ~future();
     future& operator=(const future& rhs) = delete;
-    future& operator=(future&&);
-    shared_future<void> share() &&;
+    future& operator=(future&&) noexcept;
+    shared_future<void> share();
 
     // retrieving the value
     void get();
 
     // functions to check state
-    bool valid() const;
+    bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
@@ -231,19 +231,19 @@ template <class R>
 class shared_future
 {
 public:
-    shared_future();
+    shared_future() noexcept;
     shared_future(const shared_future& rhs);
-    shared_future(future<R>&&);
-    shared_future(shared_future&& rhs);
+    shared_future(future<R>&&) noexcept;
+    shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
     shared_future& operator=(const shared_future& rhs);
-    shared_future& operator=(shared_future&& rhs);
+    shared_future& operator=(shared_future&& rhs) noexcept;
 
     // retrieving the value
     const R& get() const;
 
     // functions to check state
-    bool valid() const;
+    bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
@@ -258,19 +258,19 @@ template <class R>
 class shared_future<R&>
 {
 public:
-    shared_future();
+    shared_future() noexcept;
     shared_future(const shared_future& rhs);
-    shared_future(future<R&>&&);
-    shared_future(shared_future&& rhs);
+    shared_future(future<R&>&&) noexcept;
+    shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
     shared_future& operator=(const shared_future& rhs);
-    shared_future& operator=(shared_future&& rhs);
+    shared_future& operator=(shared_future&& rhs) noexcept;
 
     // retrieving the value
     R& get() const;
 
     // functions to check state
-    bool valid() const;
+    bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
@@ -285,19 +285,19 @@ template <>
 class shared_future<void>
 {
 public:
-    shared_future();
+    shared_future() noexcept;
     shared_future(const shared_future& rhs);
-    shared_future(future<void>&&);
-    shared_future(shared_future&& rhs);
+    shared_future(future<void>&&) noexcept;
+    shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
     shared_future& operator=(const shared_future& rhs);
-    shared_future& operator=(shared_future&& rhs);
+    shared_future& operator=(shared_future&& rhs) noexcept;
 
     // retrieving the value
     void get() const;
 
     // functions to check state
-    bool valid() const;
+    bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
@@ -325,7 +325,7 @@ public:
     typedef R result_type;
 
     // construction and destruction
-    packaged_task();
+    packaged_task() noexcept;
     template <class F>
         explicit packaged_task(F&& f);
     template <class F, class Allocator>
@@ -333,15 +333,15 @@ public:
     ~packaged_task();
 
     // no copy
-    packaged_task(packaged_task&) = delete;
-    packaged_task& operator=(packaged_task&) = delete;
+    packaged_task(const packaged_task&) = delete;
+    packaged_task& operator=(const packaged_task&) = delete;
 
     // move support
-    packaged_task(packaged_task&& other);
-    packaged_task& operator=(packaged_task&& other);
-    void swap(packaged_task& other);
+    packaged_task(packaged_task&& other) noexcept;
+    packaged_task& operator=(packaged_task&& other) noexcept;
+    void swap(packaged_task& other) noexcept;
 
-    bool valid() const;
+    bool valid() const noexcept;
 
     // result retrieval
     future<R> get_future();
@@ -354,7 +354,7 @@ public:
 };
 
 template <class R>
-  void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&);
+  void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept;
 
 template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 
@@ -370,75 +370,61 @@ template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 #include <mutex>
 #include <thread>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 //enum class future_errc
-struct _LIBCPP_VISIBLE future_errc
+_LIBCPP_DECLARE_STRONG_ENUM(future_errc)
 {
-enum _ {
     broken_promise,
     future_already_retrieved,
     promise_already_satisfied,
     no_state
 };
-
-    _ __v_;
-
-    _LIBCPP_INLINE_VISIBILITY future_errc(_ __v) : __v_(__v) {}
-    _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
-
-};
+_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 
 template <>
 struct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {};
 
+#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
+template <>
+struct _LIBCPP_VISIBLE is_error_code_enum<future_errc::__lx> : public true_type { };
+#endif
+
 //enum class launch
-struct _LIBCPP_VISIBLE launch
+_LIBCPP_DECLARE_STRONG_ENUM(launch)
 {
-enum _ {
     async = 1,
     deferred = 2,
     any = async | deferred
 };
-
-    _ __v_;
-
-    _LIBCPP_INLINE_VISIBILITY launch(_ __v) : __v_(__v) {}
-    _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
-
-};
+_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)
 
 //enum class future_status
-struct _LIBCPP_VISIBLE future_status
+_LIBCPP_DECLARE_STRONG_ENUM(future_status)
 {
-enum _ {
     ready,
     timeout,
     deferred
 };
-
-    _ __v_;
-
-    _LIBCPP_INLINE_VISIBILITY future_status(_ __v) : __v_(__v) {}
-    _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
-
-};
+_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)
 
 _LIBCPP_VISIBLE
-const error_category& future_category();
+const error_category& future_category() _NOEXCEPT;
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
-make_error_code(future_errc __e)
+make_error_code(future_errc __e) _NOEXCEPT
 {
     return error_code(static_cast<int>(__e), future_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
-make_error_condition(future_errc __e)
+make_error_condition(future_errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), future_category());
 }
@@ -451,7 +437,7 @@ public:
     future_error(error_code __ec);
 
     _LIBCPP_INLINE_VISIBILITY
-    const error_code& code() const throw() {return __ec_;}
+    const error_code& code() const _NOEXCEPT {return __ec_;}
 
     virtual ~future_error() _NOEXCEPT;
 };
@@ -484,7 +470,11 @@ public:
         {return (__state_ & __constructed) || (__exception_ != nullptr);}
 
     _LIBCPP_INLINE_VISIBILITY
-    void __set_future_attached() {__state_ |= __future_attached;}
+    void __set_future_attached()
+    {
+        lock_guard<mutex> __lk(__mut_);
+        __state_ |= __future_attached;
+    }
     _LIBCPP_INLINE_VISIBILITY
     bool __has_future_attached() const {return __state_ & __future_attached;}
 
@@ -536,14 +526,14 @@ __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) c
     return wait_until(chrono::steady_clock::now() + __rel_time);
 }
 
-template <class _R>
+template <class _Rp>
 class __assoc_state
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
-    typedef typename aligned_storage<sizeof(_R), alignment_of<_R>::value>::type _U;
+    typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
 protected:
-    _U __value_;
+    _Up __value_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
@@ -562,26 +552,26 @@ public:
         void set_value_at_thread_exit(_Arg& __arg);
 #endif
 
-    _R move();
-    typename add_lvalue_reference<_R>::type copy();
+    _Rp move();
+    typename add_lvalue_reference<_Rp>::type copy();
 };
 
-template <class _R>
+template <class _Rp>
 void
-__assoc_state<_R>::__on_zero_shared() _NOEXCEPT
+__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
 {
     if (this->__state_ & base::__constructed)
-        reinterpret_cast<_R*>(&__value_)->~_R();
+        reinterpret_cast<_Rp*>(&__value_)->~_Rp();
     delete this;
 }
 
-template <class _R>
+template <class _Rp>
 template <class _Arg>
 void
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-__assoc_state<_R>::set_value(_Arg&& __arg)
+__assoc_state<_Rp>::set_value(_Arg&& __arg)
 #else
-__assoc_state<_R>::set_value(_Arg& __arg)
+__assoc_state<_Rp>::set_value(_Arg& __arg)
 #endif
 {
     unique_lock<mutex> __lk(this->__mut_);
@@ -589,19 +579,19 @@ __assoc_state<_R>::set_value(_Arg& __arg)
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 #endif
-    ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
+    ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
     this->__state_ |= base::__constructed | base::ready;
     __lk.unlock();
     __cv_.notify_all();
 }
 
-template <class _R>
+template <class _Rp>
 template <class _Arg>
 void
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-__assoc_state<_R>::set_value_at_thread_exit(_Arg&& __arg)
+__assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)
 #else
-__assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg)
+__assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg)
 #endif
 {
     unique_lock<mutex> __lk(this->__mut_);
@@ -609,62 +599,62 @@ __assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg)
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 #endif
-    ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
+    ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
     this->__state_ |= base::__constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
     __lk.unlock();
 }
 
-template <class _R>
-_R
-__assoc_state<_R>::move()
+template <class _Rp>
+_Rp
+__assoc_state<_Rp>::move()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
         rethrow_exception(this->__exception_);
-    return _VSTD::move(*reinterpret_cast<_R*>(&__value_));
+    return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
 }
 
-template <class _R>
-typename add_lvalue_reference<_R>::type
-__assoc_state<_R>::copy()
+template <class _Rp>
+typename add_lvalue_reference<_Rp>::type
+__assoc_state<_Rp>::copy()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
         rethrow_exception(this->__exception_);
-    return *reinterpret_cast<_R*>(&__value_);
+    return *reinterpret_cast<_Rp*>(&__value_);
 }
 
-template <class _R>
-class __assoc_state<_R&>
+template <class _Rp>
+class __assoc_state<_Rp&>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
-    typedef _R* _U;
+    typedef _Rp* _Up;
 protected:
-    _U __value_;
+    _Up __value_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 
-    void set_value(_R& __arg);
-    void set_value_at_thread_exit(_R& __arg);
+    void set_value(_Rp& __arg);
+    void set_value_at_thread_exit(_Rp& __arg);
 
-    _R& copy();
+    _Rp& copy();
 };
 
-template <class _R>
+template <class _Rp>
 void
-__assoc_state<_R&>::__on_zero_shared() _NOEXCEPT
+__assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT
 {
     delete this;
 }
 
-template <class _R>
+template <class _Rp>
 void
-__assoc_state<_R&>::set_value(_R& __arg)
+__assoc_state<_Rp&>::set_value(_Rp& __arg)
 {
     unique_lock<mutex> __lk(this->__mut_);
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -677,9 +667,9 @@ __assoc_state<_R&>::set_value(_R& __arg)
     __cv_.notify_all();
 }
 
-template <class _R>
+template <class _Rp>
 void
-__assoc_state<_R&>::set_value_at_thread_exit(_R& __arg)
+__assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
 {
     unique_lock<mutex> __lk(this->__mut_);
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -692,9 +682,9 @@ __assoc_state<_R&>::set_value_at_thread_exit(_R& __arg)
     __lk.unlock();
 }
 
-template <class _R>
-_R&
-__assoc_state<_R&>::copy()
+template <class _Rp>
+_Rp&
+__assoc_state<_Rp&>::copy()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
@@ -703,11 +693,11 @@ __assoc_state<_R&>::copy()
     return *__value_;
 }
 
-template <class _R, class _Alloc>
+template <class _Rp, class _Alloc>
 class __assoc_state_alloc
-    : public __assoc_state<_R>
+    : public __assoc_state<_Rp>
 {
-    typedef __assoc_state<_R> base;
+    typedef __assoc_state<_Rp> base;
     _Alloc __alloc_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
@@ -717,22 +707,22 @@ public:
         : __alloc_(__a) {}
 };
 
-template <class _R, class _Alloc>
+template <class _Rp, class _Alloc>
 void
-__assoc_state_alloc<_R, _Alloc>::__on_zero_shared() _NOEXCEPT
+__assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     if (this->__state_ & base::__constructed)
-        reinterpret_cast<_R*>(&this->__value_)->~_R();
+        reinterpret_cast<_Rp*>(&this->__value_)->~_Rp();
     typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
     this->~__assoc_state_alloc();
     __a.deallocate(this, 1);
 }
 
-template <class _R, class _Alloc>
-class __assoc_state_alloc<_R&, _Alloc>
-    : public __assoc_state<_R&>
+template <class _Rp, class _Alloc>
+class __assoc_state_alloc<_Rp&, _Alloc>
+    : public __assoc_state<_Rp&>
 {
-    typedef __assoc_state<_R&> base;
+    typedef __assoc_state<_Rp&> base;
     _Alloc __alloc_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
@@ -742,9 +732,9 @@ public:
         : __alloc_(__a) {}
 };
 
-template <class _R, class _Alloc>
+template <class _Rp, class _Alloc>
 void
-__assoc_state_alloc<_R&, _Alloc>::__on_zero_shared() _NOEXCEPT
+__assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
     this->~__assoc_state_alloc();
@@ -769,23 +759,22 @@ template <class _Alloc>
 void
 __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
 {
-    this->~base();
     typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_);
     this->~__assoc_sub_state_alloc();
     __a.deallocate(this, 1);
 }
 
-template <class _R, class _F>
+template <class _Rp, class _Fp>
 class __deferred_assoc_state
-    : public __assoc_state<_R>
+    : public __assoc_state<_Rp>
 {
-    typedef __assoc_state<_R> base;
+    typedef __assoc_state<_Rp> base;
 
-    _F __func_;
+    _Fp __func_;
 
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    explicit __deferred_assoc_state(_F&& __f);
+    explicit __deferred_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
@@ -793,19 +782,19 @@ public:
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R, class _F>
+template <class _Rp, class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
-__deferred_assoc_state<_R, _F>::__deferred_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+__deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
+    : __func_(_VSTD::forward<_Fp>(__f))
 {
     this->__set_deferred();
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R, class _F>
+template <class _Rp, class _Fp>
 void
-__deferred_assoc_state<_R, _F>::__execute()
+__deferred_assoc_state<_Rp, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
@@ -821,17 +810,17 @@ __deferred_assoc_state<_R, _F>::__execute()
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-template <class _F>
-class __deferred_assoc_state<void, _F>
+template <class _Fp>
+class __deferred_assoc_state<void, _Fp>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
 
-    _F __func_;
+    _Fp __func_;
 
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    explicit __deferred_assoc_state(_F&& __f);
+    explicit __deferred_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
@@ -839,19 +828,19 @@ public:
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _F>
+template <class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
-__deferred_assoc_state<void, _F>::__deferred_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+__deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
+    : __func_(_VSTD::forward<_Fp>(__f))
 {
     this->__set_deferred();
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _F>
+template <class _Fp>
 void
-__deferred_assoc_state<void, _F>::__execute()
+__deferred_assoc_state<void, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
@@ -868,18 +857,18 @@ __deferred_assoc_state<void, _F>::__execute()
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-template <class _R, class _F>
+template <class _Rp, class _Fp>
 class __async_assoc_state
-    : public __assoc_state<_R>
+    : public __assoc_state<_Rp>
 {
-    typedef __assoc_state<_R> base;
+    typedef __assoc_state<_Rp> base;
 
-    _F __func_;
+    _Fp __func_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    explicit __async_assoc_state(_F&& __f);
+    explicit __async_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
@@ -887,18 +876,18 @@ public:
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R, class _F>
+template <class _Rp, class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
-__async_assoc_state<_R, _F>::__async_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
+    : __func_(_VSTD::forward<_Fp>(__f))
 {
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R, class _F>
+template <class _Rp, class _Fp>
 void
-__async_assoc_state<_R, _F>::__execute()
+__async_assoc_state<_Rp, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
@@ -914,26 +903,26 @@ __async_assoc_state<_R, _F>::__execute()
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-template <class _R, class _F>
+template <class _Rp, class _Fp>
 void
-__async_assoc_state<_R, _F>::__on_zero_shared() _NOEXCEPT
+__async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT
 {
     this->wait();
     base::__on_zero_shared();
 }
 
-template <class _F>
-class __async_assoc_state<void, _F>
+template <class _Fp>
+class __async_assoc_state<void, _Fp>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
 
-    _F __func_;
+    _Fp __func_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    explicit __async_assoc_state(_F&& __f);
+    explicit __async_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
@@ -941,18 +930,18 @@ public:
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _F>
+template <class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
-__async_assoc_state<void, _F>::__async_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+__async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
+    : __func_(_VSTD::forward<_Fp>(__f))
 {
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _F>
+template <class _Fp>
 void
-__async_assoc_state<void, _F>::__execute()
+__async_assoc_state<void, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
@@ -969,70 +958,70 @@ __async_assoc_state<void, _F>::__execute()
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-template <class _F>
+template <class _Fp>
 void
-__async_assoc_state<void, _F>::__on_zero_shared() _NOEXCEPT
+__async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
 {
     this->wait();
     base::__on_zero_shared();
 }
 
-template <class _R> class promise;
-template <class _R> class shared_future;
+template <class _Rp> class _LIBCPP_VISIBLE promise;
+template <class _Rp> class _LIBCPP_VISIBLE shared_future;
 
 // future
 
-template <class _R> class future;
+template <class _Rp> class _LIBCPP_VISIBLE future;
 
-template <class _R, class _F>
-future<_R>
+template <class _Rp, class _Fp>
+future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-__make_deferred_assoc_state(_F&& __f);
+__make_deferred_assoc_state(_Fp&& __f);
 #else
-__make_deferred_assoc_state(_F __f);
+__make_deferred_assoc_state(_Fp __f);
 #endif
 
-template <class _R, class _F>
-future<_R>
+template <class _Rp, class _Fp>
+future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-__make_async_assoc_state(_F&& __f);
+__make_async_assoc_state(_Fp&& __f);
 #else
-__make_async_assoc_state(_F __f);
+__make_async_assoc_state(_Fp __f);
 #endif
 
-template <class _R>
+template <class _Rp>
 class _LIBCPP_VISIBLE future
 {
-    __assoc_state<_R>* __state_;
+    __assoc_state<_Rp>* __state_;
 
-    explicit future(__assoc_state<_R>* __state);
+    explicit future(__assoc_state<_Rp>* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    template <class _R1, class _F>
-        friend future<_R1> __make_deferred_assoc_state(_F&& __f);
-    template <class _R1, class _F>
-        friend future<_R1> __make_async_assoc_state(_F&& __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 #else
-    template <class _R1, class _F>
-        friend future<_R1> __make_deferred_assoc_state(_F __f);
-    template <class _R1, class _F>
-        friend future<_R1> __make_async_assoc_state(_F __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_deferred_assoc_state(_Fp __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_async_assoc_state(_Fp __f);
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    future() : __state_(nullptr) {}
+    future() _NOEXCEPT : __state_(nullptr) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    future(future&& __rhs)
+    future(future&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     future(const future&) = delete;
     future& operator=(const future&) = delete;
     _LIBCPP_INLINE_VISIBILITY
-    future& operator=(future&& __rhs)
+    future& operator=(future&& __rhs) _NOEXCEPT
         {
             future(std::move(__rhs)).swap(*this);
             return *this;
@@ -1044,17 +1033,17 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
-    shared_future<_R> share();
+    shared_future<_Rp> share();
 
     // retrieving the value
-    _R get();
+    _Rp get();
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
@@ -1070,8 +1059,8 @@ public:
             {return __state_->wait_until(__abs_time);}
 };
 
-template <class _R>
-future<_R>::future(__assoc_state<_R>* __state)
+template <class _Rp>
+future<_Rp>::future(__assoc_state<_Rp>* __state)
     : __state_(__state)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1087,56 +1076,56 @@ struct __release_shared_count
     void operator()(__shared_count* p) {p->__release_shared();}
 };
 
-template <class _R>
-future<_R>::~future()
+template <class _Rp>
+future<_Rp>::~future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
-template <class _R>
-_R
-future<_R>::get()
+template <class _Rp>
+_Rp
+future<_Rp>::get()
 {
     unique_ptr<__shared_count, __release_shared_count> __(__state_);
-    __assoc_state<_R>* __s = __state_;
+    __assoc_state<_Rp>* __s = __state_;
     __state_ = nullptr;
     return __s->move();
 }
 
-template <class _R>
-class _LIBCPP_VISIBLE future<_R&>
+template <class _Rp>
+class _LIBCPP_VISIBLE future<_Rp&>
 {
-    __assoc_state<_R&>* __state_;
+    __assoc_state<_Rp&>* __state_;
 
-    explicit future(__assoc_state<_R&>* __state);
+    explicit future(__assoc_state<_Rp&>* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    template <class _R1, class _F>
-        friend future<_R1> __make_deferred_assoc_state(_F&& __f);
-    template <class _R1, class _F>
-        friend future<_R1> __make_async_assoc_state(_F&& __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 #else
-    template <class _R1, class _F>
-        friend future<_R1> __make_deferred_assoc_state(_F __f);
-    template <class _R1, class _F>
-        friend future<_R1> __make_async_assoc_state(_F __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_deferred_assoc_state(_Fp __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_async_assoc_state(_Fp __f);
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    future() : __state_(nullptr) {}
+    future() _NOEXCEPT : __state_(nullptr) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    future(future&& __rhs)
+    future(future&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     future(const future&) = delete;
     future& operator=(const future&) = delete;
     _LIBCPP_INLINE_VISIBILITY
-    future& operator=(future&& __rhs)
+    future& operator=(future&& __rhs) _NOEXCEPT
         {
             future(std::move(__rhs)).swap(*this);
             return *this;
@@ -1148,17 +1137,17 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
-    shared_future<_R&> share();
+    shared_future<_Rp&> share();
 
     // retrieving the value
-    _R& get();
+    _Rp& get();
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
@@ -1174,8 +1163,8 @@ public:
             {return __state_->wait_until(__abs_time);}
 };
 
-template <class _R>
-future<_R&>::future(__assoc_state<_R&>* __state)
+template <class _Rp>
+future<_Rp&>::future(__assoc_state<_Rp&>* __state)
     : __state_(__state)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1186,19 +1175,19 @@ future<_R&>::future(__assoc_state<_R&>* __state)
     __state_->__set_future_attached();
 }
 
-template <class _R>
-future<_R&>::~future()
+template <class _Rp>
+future<_Rp&>::~future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
-template <class _R>
-_R&
-future<_R&>::get()
+template <class _Rp>
+_Rp&
+future<_Rp&>::get()
 {
     unique_ptr<__shared_count, __release_shared_count> __(__state_);
-    __assoc_state<_R&>* __s = __state_;
+    __assoc_state<_Rp&>* __s = __state_;
     __state_ = nullptr;
     return __s->copy();
 }
@@ -1214,28 +1203,28 @@ class _LIBCPP_VISIBLE future<void>
     template <class> friend class shared_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    template <class _R1, class _F>
-        friend future<_R1> __make_deferred_assoc_state(_F&& __f);
-    template <class _R1, class _F>
-        friend future<_R1> __make_async_assoc_state(_F&& __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 #else
-    template <class _R1, class _F>
-        friend future<_R1> __make_deferred_assoc_state(_F __f);
-    template <class _R1, class _F>
-        friend future<_R1> __make_async_assoc_state(_F __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_deferred_assoc_state(_Fp __f);
+    template <class _R1, class _Fp>
+        friend future<_R1> __make_async_assoc_state(_Fp __f);
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    future() : __state_(nullptr) {}
+    future() _NOEXCEPT : __state_(nullptr) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    future(future&& __rhs)
+    future(future&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     future(const future&) = delete;
     future& operator=(const future&) = delete;
     _LIBCPP_INLINE_VISIBILITY
-    future& operator=(future&& __rhs)
+    future& operator=(future&& __rhs) _NOEXCEPT
         {
             future(std::move(__rhs)).swap(*this);
             return *this;
@@ -1253,11 +1242,11 @@ public:
     void get();
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
@@ -1273,10 +1262,10 @@ public:
             {return __state_->wait_until(__abs_time);}
 };
 
-template <class _R>
+template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-swap(future<_R>& __x, future<_R>& __y)
+swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
@@ -1285,13 +1274,13 @@ swap(future<_R>& __x, future<_R>& __y)
 
 template <class _Callable> class packaged_task;
 
-template <class _R>
+template <class _Rp>
 class _LIBCPP_VISIBLE promise
 {
-    __assoc_state<_R>* __state_;
+    __assoc_state<_Rp>* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit promise(nullptr_t) : __state_(nullptr) {}
+    explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 public:
@@ -1300,7 +1289,7 @@ public:
         promise(allocator_arg_t, const _Alloc& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    promise(promise&& __rhs)
+    promise(promise&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     promise(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1313,7 +1302,7 @@ public:
     // assignment
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    promise& operator=(promise&& __rhs)
+    promise& operator=(promise&& __rhs) _NOEXCEPT
         {
             promise(std::move(__rhs)).swap(*this);
             return *this;
@@ -1325,46 +1314,46 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
-    future<_R> get_future();
+    future<_Rp> get_future();
 
     // setting the result
-    void set_value(const _R& __r);
+    void set_value(const _Rp& __r);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void set_value(_R&& __r);
+    void set_value(_Rp&& __r);
 #endif
     void set_exception(exception_ptr __p);
 
     // setting the result with deferred notification
-    void set_value_at_thread_exit(const _R& __r);
+    void set_value_at_thread_exit(const _Rp& __r);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void set_value_at_thread_exit(_R&& __r);
+    void set_value_at_thread_exit(_Rp&& __r);
 #endif
     void set_exception_at_thread_exit(exception_ptr __p);
 };
 
-template <class _R>
-promise<_R>::promise()
-    : __state_(new __assoc_state<_R>)
+template <class _Rp>
+promise<_Rp>::promise()
+    : __state_(new __assoc_state<_Rp>)
 {
 }
 
-template <class _R>
+template <class _Rp>
 template <class _Alloc>
-promise<_R>::promise(allocator_arg_t, const _Alloc& __a0)
+promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
 {
-    typedef typename _Alloc::template rebind<__assoc_state_alloc<_R, _Alloc> >::other _A2;
+    typedef typename _Alloc::template rebind<__assoc_state_alloc<_Rp, _Alloc> >::other _A2;
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a(__a0);
-    unique_ptr<__assoc_state_alloc<_R, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
-    ::new(__hold.get()) __assoc_state_alloc<_R, _Alloc>(__a0);
+    unique_ptr<__assoc_state_alloc<_Rp, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
+    ::new(__hold.get()) __assoc_state_alloc<_Rp, _Alloc>(__a0);
     __state_ = __hold.release();
 }
 
-template <class _R>
-promise<_R>::~promise()
+template <class _Rp>
+promise<_Rp>::~promise()
 {
     if (__state_)
     {
@@ -1376,20 +1365,20 @@ promise<_R>::~promise()
     }
 }
 
-template <class _R>
-future<_R>
-promise<_R>::get_future()
+template <class _Rp>
+future<_Rp>
+promise<_Rp>::get_future()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
 #endif
-    return future<_R>(__state_);
+    return future<_Rp>(__state_);
 }
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R>::set_value(const _R& __r)
+promise<_Rp>::set_value(const _Rp& __r)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1400,9 +1389,9 @@ promise<_R>::set_value(const _R& __r)
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R>::set_value(_R&& __r)
+promise<_Rp>::set_value(_Rp&& __r)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1413,9 +1402,9 @@ promise<_R>::set_value(_R&& __r)
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R>::set_exception(exception_ptr __p)
+promise<_Rp>::set_exception(exception_ptr __p)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1424,9 +1413,9 @@ promise<_R>::set_exception(exception_ptr __p)
     __state_->set_exception(__p);
 }
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R>::set_value_at_thread_exit(const _R& __r)
+promise<_Rp>::set_value_at_thread_exit(const _Rp& __r)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1437,9 +1426,9 @@ promise<_R>::set_value_at_thread_exit(const _R& __r)
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R>::set_value_at_thread_exit(_R&& __r)
+promise<_Rp>::set_value_at_thread_exit(_Rp&& __r)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1450,9 +1439,9 @@ promise<_R>::set_value_at_thread_exit(_R&& __r)
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R>::set_exception_at_thread_exit(exception_ptr __p)
+promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1463,13 +1452,13 @@ promise<_R>::set_exception_at_thread_exit(exception_ptr __p)
 
 // promise<R&>
 
-template <class _R>
-class _LIBCPP_VISIBLE promise<_R&>
+template <class _Rp>
+class _LIBCPP_VISIBLE promise<_Rp&>
 {
-    __assoc_state<_R&>* __state_;
+    __assoc_state<_Rp&>* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit promise(nullptr_t) : __state_(nullptr) {}
+    explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 
@@ -1479,7 +1468,7 @@ public:
         promise(allocator_arg_t, const _Allocator& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    promise(promise&& __rhs)
+    promise(promise&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     promise(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1492,7 +1481,7 @@ public:
     // assignment
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    promise& operator=(promise&& __rhs)
+    promise& operator=(promise&& __rhs) _NOEXCEPT
         {
             promise(std::move(__rhs)).swap(*this);
             return *this;
@@ -1504,40 +1493,40 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
-    future<_R&> get_future();
+    future<_Rp&> get_future();
 
     // setting the result
-    void set_value(_R& __r);
+    void set_value(_Rp& __r);
     void set_exception(exception_ptr __p);
 
     // setting the result with deferred notification
-    void set_value_at_thread_exit(_R&);
+    void set_value_at_thread_exit(_Rp&);
     void set_exception_at_thread_exit(exception_ptr __p);
 };
 
-template <class _R>
-promise<_R&>::promise()
-    : __state_(new __assoc_state<_R&>)
+template <class _Rp>
+promise<_Rp&>::promise()
+    : __state_(new __assoc_state<_Rp&>)
 {
 }
 
-template <class _R>
+template <class _Rp>
 template <class _Alloc>
-promise<_R&>::promise(allocator_arg_t, const _Alloc& __a0)
+promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
 {
-    typedef typename _Alloc::template rebind<__assoc_state_alloc<_R&, _Alloc> >::other _A2;
+    typedef typename _Alloc::template rebind<__assoc_state_alloc<_Rp&, _Alloc> >::other _A2;
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a(__a0);
-    unique_ptr<__assoc_state_alloc<_R&, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
-    ::new(__hold.get()) __assoc_state_alloc<_R&, _Alloc>(__a0);
+    unique_ptr<__assoc_state_alloc<_Rp&, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
+    ::new(__hold.get()) __assoc_state_alloc<_Rp&, _Alloc>(__a0);
     __state_ = __hold.release();
 }
 
-template <class _R>
-promise<_R&>::~promise()
+template <class _Rp>
+promise<_Rp&>::~promise()
 {
     if (__state_)
     {
@@ -1549,20 +1538,20 @@ promise<_R&>::~promise()
     }
 }
 
-template <class _R>
-future<_R&>
-promise<_R&>::get_future()
+template <class _Rp>
+future<_Rp&>
+promise<_Rp&>::get_future()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
 #endif
-    return future<_R&>(__state_);
+    return future<_Rp&>(__state_);
 }
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R&>::set_value(_R& __r)
+promise<_Rp&>::set_value(_Rp& __r)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1571,9 +1560,9 @@ promise<_R&>::set_value(_R& __r)
     __state_->set_value(__r);
 }
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R&>::set_exception(exception_ptr __p)
+promise<_Rp&>::set_exception(exception_ptr __p)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1582,9 +1571,9 @@ promise<_R&>::set_exception(exception_ptr __p)
     __state_->set_exception(__p);
 }
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R&>::set_value_at_thread_exit(_R& __r)
+promise<_Rp&>::set_value_at_thread_exit(_Rp& __r)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1593,9 +1582,9 @@ promise<_R&>::set_value_at_thread_exit(_R& __r)
     __state_->set_value_at_thread_exit(__r);
 }
 
-template <class _R>
+template <class _Rp>
 void
-promise<_R&>::set_exception_at_thread_exit(exception_ptr __p)
+promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
@@ -1612,7 +1601,7 @@ class _LIBCPP_VISIBLE promise<void>
     __assoc_sub_state* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit promise(nullptr_t) : __state_(nullptr) {}
+    explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 
@@ -1622,7 +1611,7 @@ public:
         promise(allocator_arg_t, const _Allocator& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    promise(promise&& __rhs)
+    promise(promise&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     promise(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1635,7 +1624,7 @@ public:
     // assignment
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    promise& operator=(promise&& __rhs)
+    promise& operator=(promise&& __rhs) _NOEXCEPT
         {
             promise(std::move(__rhs)).swap(*this);
             return *this;
@@ -1647,7 +1636,7 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
     future<void> get_future();
@@ -1672,16 +1661,16 @@ promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
     __state_ = __hold.release();
 }
 
-template <class _R>
+template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-swap(promise<_R>& __x, promise<_R>& __y)
+swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
-template <class _R, class _Alloc>
-    struct _LIBCPP_VISIBLE uses_allocator<promise<_R>, _Alloc>
+template <class _Rp, class _Alloc>
+    struct _LIBCPP_VISIBLE uses_allocator<promise<_Rp>, _Alloc>
         : public true_type {};
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -1690,8 +1679,8 @@ template <class _R, class _Alloc>
 
 template<class _Fp> class __packaged_task_base;
 
-template<class _R, class ..._ArgTypes>
-class __packaged_task_base<_R(_ArgTypes...)>
+template<class _Rp, class ..._ArgTypes>
+class __packaged_task_base<_Rp(_ArgTypes...)>
 {
     __packaged_task_base(const __packaged_task_base&);
     __packaged_task_base& operator=(const __packaged_task_base&);
@@ -1700,103 +1689,103 @@ public:
     __packaged_task_base() {}
     _LIBCPP_INLINE_VISIBILITY
     virtual ~__packaged_task_base() {}
-    virtual void __move_to(__packaged_task_base*) = 0;
+    virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
     virtual void destroy() = 0;
     virtual void destroy_deallocate() = 0;
-    virtual _R operator()(_ArgTypes&& ...) = 0;
+    virtual _Rp operator()(_ArgTypes&& ...) = 0;
 };
 
 template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
 
-template<class _F, class _Alloc, class _R, class ..._ArgTypes>
-class __packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>
-    : public  __packaged_task_base<_R(_ArgTypes...)>
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+class __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
+    : public  __packaged_task_base<_Rp(_ArgTypes...)>
 {
-    __compressed_pair<_F, _Alloc> __f_;
+    __compressed_pair<_Fp, _Alloc> __f_;
 public:
     _LIBCPP_INLINE_VISIBILITY
-    explicit __packaged_task_func(const _F& __f) : __f_(__f) {}
+    explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit __packaged_task_func(_F&& __f) : __f_(_VSTD::move(__f)) {}
+    explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {}
     _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_func(const _F& __f, const _Alloc& __a)
+    __packaged_task_func(const _Fp& __f, const _Alloc& __a)
         : __f_(__f, __a) {}
     _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_func(_F&& __f, const _Alloc& __a)
+    __packaged_task_func(_Fp&& __f, const _Alloc& __a)
         : __f_(_VSTD::move(__f), __a) {}
-    virtual void __move_to(__packaged_task_base<_R(_ArgTypes...)>*);
+    virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
     virtual void destroy();
     virtual void destroy_deallocate();
-    virtual _R operator()(_ArgTypes&& ... __args);
+    virtual _Rp operator()(_ArgTypes&& ... __args);
 };
 
-template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
-__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::__move_to(
-                              __packaged_task_base<_R(_ArgTypes...)>* __p)
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
+                              __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
 {
     ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
 }
 
-template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
-__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::destroy()
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
 {
-    __f_.~__compressed_pair<_F, _Alloc>();
+    __f_.~__compressed_pair<_Fp, _Alloc>();
 }
 
-template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
-__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate()
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
 {
-    typedef typename _Alloc::template rebind<__packaged_task_func>::other _A;
-    _A __a(__f_.second());
-    __f_.~__compressed_pair<_F, _Alloc>();
+    typedef typename _Alloc::template rebind<__packaged_task_func>::other _Ap;
+    _Ap __a(__f_.second());
+    __f_.~__compressed_pair<_Fp, _Alloc>();
     __a.deallocate(this, 1);
 }
 
-template<class _F, class _Alloc, class _R, class ..._ArgTypes>
-_R
-__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+_Rp
+__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 {
     return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 template <class _Callable> class __packaged_task_function;
 
-template<class _R, class ..._ArgTypes>
-class __packaged_task_function<_R(_ArgTypes...)>
+template<class _Rp, class ..._ArgTypes>
+class __packaged_task_function<_Rp(_ArgTypes...)>
 {
-    typedef __packaged_task_base<_R(_ArgTypes...)> __base;
-    aligned_storage<3*sizeof(void*)>::type __buf_;
+    typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
+    typename aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
 public:
-    typedef _R result_type;
+    typedef _Rp result_type;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_function() : __f_(nullptr) {}
-    template<class _F>
-      __packaged_task_function(_F&& __f);
-    template<class _F, class _Alloc>
-      __packaged_task_function(allocator_arg_t, const _Alloc& __a, _F&& __f);
+    __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
+    template<class _Fp>
+      __packaged_task_function(_Fp&& __f);
+    template<class _Fp, class _Alloc>
+      __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);
 
-    __packaged_task_function(__packaged_task_function&&);
-    __packaged_task_function& operator=(__packaged_task_function&&);
+    __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
+    __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;
 
     __packaged_task_function(const __packaged_task_function&) =  delete;
     __packaged_task_function& operator=(const __packaged_task_function&) =  delete;
 
     ~__packaged_task_function();
 
-    void swap(__packaged_task_function&);
+    void swap(__packaged_task_function&) _NOEXCEPT;
 
-    _R operator()(_ArgTypes...) const;
+    _Rp operator()(_ArgTypes...) const;
 };
 
-template<class _R, class ..._ArgTypes>
-__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f)
+template<class _Rp, class ..._ArgTypes>
+__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
 {
     if (__f.__f_ == nullptr)
         __f_ = nullptr;
@@ -1812,42 +1801,42 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(__packaged_
     }
 }
 
-template<class _R, class ..._ArgTypes>
-template <class _F>
-__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f)
+template<class _Rp, class ..._ArgTypes>
+template <class _Fp>
+__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
     : __f_(nullptr)
 {
-    typedef typename remove_reference<_F>::type _FR;
-    typedef __packaged_task_func<_FR, allocator<_FR>, _R(_ArgTypes...)> _FF;
+    typedef typename remove_reference<_Fp>::type _FR;
+    typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
     if (sizeof(_FF) <= sizeof(__buf_))
     {
         __f_ = (__base*)&__buf_;
-        ::new (__f_) _FF(_VSTD::forward<_F>(__f));
+        ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
     }
     else
     {
-        typedef allocator<_FF> _A;
-        _A __a;
-        typedef __allocator_destructor<_A> _D;
-        unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
-        ::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), allocator<_FR>(__a));
+        typedef allocator<_FF> _Ap;
+        _Ap __a;
+        typedef __allocator_destructor<_Ap> _Dp;
+        unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+        ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
         __f_ = __hold.release();
     }
 }
 
-template<class _R, class ..._ArgTypes>
-template <class _F, class _Alloc>
-__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
-                                  allocator_arg_t, const _Alloc& __a0, _F&& __f)
+template<class _Rp, class ..._ArgTypes>
+template <class _Fp, class _Alloc>
+__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
+                                  allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
     : __f_(nullptr)
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
-    typedef typename remove_reference<_F>::type _FR;
-    typedef __packaged_task_func<_FR, _Alloc, _R(_ArgTypes...)> _FF;
+    typedef typename remove_reference<_Fp>::type _FR;
+    typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
     if (sizeof(_FF) <= sizeof(__buf_))
     {
         __f_ = (__base*)&__buf_;
-        ::new (__f_) _FF(_VSTD::forward<_F>(__f));
+        ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
     }
     else
     {
@@ -1857,18 +1846,18 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
 #else
             rebind_alloc<_FF>::other
 #endif
-                                                     _A;
-        _A __a(__a0);
-        typedef __allocator_destructor<_A> _D;
-        unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
-        ::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), _Alloc(__a));
+                                                     _Ap;
+        _Ap __a(__a0);
+        typedef __allocator_destructor<_Ap> _Dp;
+        unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+        ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a));
         __f_ = __hold.release();
     }
 }
 
-template<class _R, class ..._ArgTypes>
-__packaged_task_function<_R(_ArgTypes...)>&
-__packaged_task_function<_R(_ArgTypes...)>::operator=(__packaged_task_function&& __f)
+template<class _Rp, class ..._ArgTypes>
+__packaged_task_function<_Rp(_ArgTypes...)>&
+__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT
 {
     if (__f_ == (__base*)&__buf_)
         __f_->destroy();
@@ -1887,10 +1876,11 @@ __packaged_task_function<_R(_ArgTypes...)>::operator=(__packaged_task_function&&
         __f_ = __f.__f_;
         __f.__f_ = nullptr;
     }
+    return *this;
 }
 
-template<class _R, class ..._ArgTypes>
-__packaged_task_function<_R(_ArgTypes...)>::~__packaged_task_function()
+template<class _Rp, class ..._ArgTypes>
+__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function()
 {
     if (__f_ == (__base*)&__buf_)
         __f_->destroy();
@@ -1898,9 +1888,9 @@ __packaged_task_function<_R(_ArgTypes...)>::~__packaged_task_function()
         __f_->destroy_deallocate();
 }
 
-template<class _R, class ..._ArgTypes>
+template<class _Rp, class ..._ArgTypes>
 void
-__packaged_task_function<_R(_ArgTypes...)>::swap(__packaged_task_function& __f)
+__packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT
 {
     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
     {
@@ -1935,19 +1925,19 @@ __packaged_task_function<_R(_ArgTypes...)>::swap(__packaged_task_function& __f)
         _VSTD::swap(__f_, __f.__f_);
 }
 
-template<class _R, class ..._ArgTypes>
+template<class _Rp, class ..._ArgTypes>
 inline _LIBCPP_INLINE_VISIBILITY
-_R
-__packaged_task_function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
+_Rp
+__packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
 {
     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
 }
 
-template<class _R, class ..._ArgTypes>
-class _LIBCPP_VISIBLE packaged_task<_R(_ArgTypes...)>
+template<class _Rp, class ..._ArgTypes>
+class _LIBCPP_VISIBLE packaged_task<_Rp(_ArgTypes...)>
 {
 public:
-    typedef _R result_type;
+    typedef _Rp result_type;
 
 private:
     __packaged_task_function<result_type(_ArgTypes...)> __f_;
@@ -1956,41 +1946,41 @@ private:
 public:
     // construction and destruction
     _LIBCPP_INLINE_VISIBILITY
-    packaged_task() : __p_(nullptr) {}
-    template <class _F>
+    packaged_task() _NOEXCEPT : __p_(nullptr) {}
+    template <class _Fp>
         _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
-    template <class _F, class _Allocator>
+        explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
+    template <class _Fp, class _Allocator>
         _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
-             : __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)),
+        explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
+             : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
                __p_(allocator_arg, __a) {}
     // ~packaged_task() = default;
 
     // no copy
-    packaged_task(packaged_task&) = delete;
-    packaged_task& operator=(packaged_task&) = delete;
+    packaged_task(const packaged_task&) = delete;
+    packaged_task& operator=(const packaged_task&) = delete;
 
     // move support
     _LIBCPP_INLINE_VISIBILITY
-    packaged_task(packaged_task&& __other)
+    packaged_task(packaged_task&& __other) _NOEXCEPT
         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
     _LIBCPP_INLINE_VISIBILITY
-    packaged_task& operator=(packaged_task&& __other)
+    packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
     {
         __f_ = _VSTD::move(__other.__f_);
         __p_ = _VSTD::move(__other.__p_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
-    void swap(packaged_task& __other)
+    void swap(packaged_task& __other) _NOEXCEPT
     {
         __f_.swap(__other.__f_);
         __p_.swap(__other.__p_);
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __p_.__state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
 
     // result retrieval
     _LIBCPP_INLINE_VISIBILITY
@@ -2003,9 +1993,9 @@ public:
     void reset();
 };
 
-template<class _R, class ..._ArgTypes>
+template<class _Rp, class ..._ArgTypes>
 void
-packaged_task<_R(_ArgTypes...)>::operator()(_ArgTypes... __args)
+packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__p_.__state_ == nullptr)
@@ -2025,9 +2015,9 @@ packaged_task<_R(_ArgTypes...)>::operator()(_ArgTypes... __args)
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-template<class _R, class ..._ArgTypes>
+template<class _Rp, class ..._ArgTypes>
 void
-packaged_task<_R(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
+packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__p_.__state_ == nullptr)
@@ -2047,9 +2037,9 @@ packaged_task<_R(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-template<class _R, class ..._ArgTypes>
+template<class _Rp, class ..._ArgTypes>
 void
-packaged_task<_R(_ArgTypes...)>::reset()
+packaged_task<_Rp(_ArgTypes...)>::reset()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (!valid())
@@ -2071,41 +2061,41 @@ private:
 public:
     // construction and destruction
     _LIBCPP_INLINE_VISIBILITY
-    packaged_task() : __p_(nullptr) {}
-    template <class _F>
+    packaged_task() _NOEXCEPT : __p_(nullptr) {}
+    template <class _Fp>
         _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
-    template <class _F, class _Allocator>
+        explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
+    template <class _Fp, class _Allocator>
         _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
-             : __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)),
+        explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
+             : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
                __p_(allocator_arg, __a) {}
     // ~packaged_task() = default;
 
     // no copy
-    packaged_task(packaged_task&) = delete;
-    packaged_task& operator=(packaged_task&) = delete;
+    packaged_task(const packaged_task&) = delete;
+    packaged_task& operator=(const packaged_task&) = delete;
 
     // move support
     _LIBCPP_INLINE_VISIBILITY
-    packaged_task(packaged_task&& __other)
+    packaged_task(packaged_task&& __other) _NOEXCEPT
         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
     _LIBCPP_INLINE_VISIBILITY
-    packaged_task& operator=(packaged_task&& __other)
+    packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
     {
         __f_ = _VSTD::move(__other.__f_);
         __p_ = _VSTD::move(__other.__p_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
-    void swap(packaged_task& __other)
+    void swap(packaged_task& __other) _NOEXCEPT
     {
         __f_.swap(__other.__f_);
         __p_.swap(__other.__p_);
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __p_.__state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
 
     // result retrieval
     _LIBCPP_INLINE_VISIBILITY
@@ -2178,7 +2168,7 @@ packaged_task<void(_ArgTypes...)>::reset()
 template <class _Callable>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y)
+swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
@@ -2187,84 +2177,84 @@ template <class _Callable, class _Alloc>
 struct _LIBCPP_VISIBLE uses_allocator<packaged_task<_Callable>, _Alloc>
     : public true_type {};
 
-template <class _R, class _F>
-future<_R>
+template <class _Rp, class _Fp>
+future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-__make_deferred_assoc_state(_F&& __f)
+__make_deferred_assoc_state(_Fp&& __f)
 #else
-__make_deferred_assoc_state(_F __f)
+__make_deferred_assoc_state(_Fp __f)
 #endif
 {
-    unique_ptr<__deferred_assoc_state<_R, _F>, __release_shared_count>
-        __h(new __deferred_assoc_state<_R, _F>(_VSTD::forward<_F>(__f)));
-    return future<_R>(__h.get());
+    unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
+        __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
+    return future<_Rp>(__h.get());
 }
 
-template <class _R, class _F>
-future<_R>
+template <class _Rp, class _Fp>
+future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-__make_async_assoc_state(_F&& __f)
+__make_async_assoc_state(_Fp&& __f)
 #else
-__make_async_assoc_state(_F __f)
+__make_async_assoc_state(_Fp __f)
 #endif
 {
-    unique_ptr<__async_assoc_state<_R, _F>, __release_shared_count>
-        __h(new __async_assoc_state<_R, _F>(_VSTD::forward<_F>(__f)));
-    _VSTD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach();
-    return future<_R>(__h.get());
+    unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
+        __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
+    _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
+    return future<_Rp>(__h.get());
 }
 
-template <class _F, class... _Args>
+template <class _Fp, class... _Args>
 class __async_func
 {
-    tuple<_F, _Args...> __f_;
+    tuple<_Fp, _Args...> __f_;
 
 public:
-    typedef typename __invoke_of<_F, _Args...>::type _R;
+    typedef typename __invoke_of<_Fp, _Args...>::type _Rp;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __async_func(_F&& __f, _Args&&... __args)
+    explicit __async_func(_Fp&& __f, _Args&&... __args)
         : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
 
     _LIBCPP_INLINE_VISIBILITY
     __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
 
-    _R operator()()
+    _Rp operator()()
     {
         typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index;
         return __execute(_Index());
     }
 private:
     template <size_t ..._Indices>
-    _R
+    _Rp
     __execute(__tuple_indices<_Indices...>)
     {
         return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
     }
 };
 
-template <class _F, class... _Args>
-future<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type>
-async(launch __policy, _F&& __f, _Args&&... __args)
+template <class _Fp, class... _Args>
+future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
+async(launch __policy, _Fp&& __f, _Args&&... __args)
 {
-    typedef __async_func<typename decay<_F>::type, typename decay<_Args>::type...> _BF;
-    typedef typename _BF::_R _R;
-    future<_R> __r;
-    if (__policy & launch::async)
-        __r = _VSTD::__make_async_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
+    typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
+    typedef typename _BF::_Rp _Rp;
+    future<_Rp> __r;
+    if (int(__policy) & int(launch::async))
+        __r = _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
                                                      __decay_copy(_VSTD::forward<_Args>(__args))...));
-    else if (__policy & launch::deferred)
-        __r = _VSTD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
+    else if (int(__policy) & int(launch::deferred))
+        __r = _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
                                                         __decay_copy(_VSTD::forward<_Args>(__args))...));
     return __r;
 }
 
-template <class _F, class... _Args>
+template <class _Fp, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY
-future<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type>
-async(_F&& __f, _Args&&... __args)
+future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
+async(_Fp&& __f, _Args&&... __args)
 {
-    return _VSTD::async(launch::any, _VSTD::forward<_F>(__f),
+    return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
                                     _VSTD::forward<_Args>(__args)...);
 }
 
@@ -2272,30 +2262,30 @@ async(_F&& __f, _Args&&... __args)
 
 // shared_future
 
-template <class _R>
+template <class _Rp>
 class _LIBCPP_VISIBLE shared_future
 {
-    __assoc_state<_R>* __state_;
+    __assoc_state<_Rp>* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    shared_future() : __state_(nullptr) {}
+    shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
         {if (__state_) __state_->__add_shared();}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    shared_future(future<_R>&& __f) : __state_(__f.__state_)
+    shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_)
         {__f.__state_ = nullptr;}
     _LIBCPP_INLINE_VISIBILITY
-    shared_future(shared_future&& __rhs) : __state_(__rhs.__state_)
+    shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
         {__rhs.__state_ = nullptr;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~shared_future();
     shared_future& operator=(const shared_future& __rhs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    shared_future& operator=(shared_future&& __rhs)
+    shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
         {
             shared_future(std::move(__rhs)).swap(*this);
             return *this;
@@ -2304,14 +2294,14 @@ public:
 
     // retrieving the value
     _LIBCPP_INLINE_VISIBILITY
-    const _R& get() const {return __state_->copy();}
+    const _Rp& get() const {return __state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
@@ -2327,16 +2317,16 @@ public:
             {return __state_->wait_until(__abs_time);}
 };
 
-template <class _R>
-shared_future<_R>::~shared_future()
+template <class _Rp>
+shared_future<_Rp>::~shared_future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
-template <class _R>
-shared_future<_R>&
-shared_future<_R>::operator=(const shared_future& __rhs)
+template <class _Rp>
+shared_future<_Rp>&
+shared_future<_Rp>::operator=(const shared_future& __rhs)
 {
     if (__rhs.__state_)
         __rhs.__state_->__add_shared();
@@ -2346,30 +2336,30 @@ shared_future<_R>::operator=(const shared_future& __rhs)
     return *this;
 }
 
-template <class _R>
-class _LIBCPP_VISIBLE shared_future<_R&>
+template <class _Rp>
+class _LIBCPP_VISIBLE shared_future<_Rp&>
 {
-    __assoc_state<_R&>* __state_;
+    __assoc_state<_Rp&>* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    shared_future() : __state_(nullptr) {}
+    shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
         {if (__state_) __state_->__add_shared();}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    shared_future(future<_R&>&& __f) : __state_(__f.__state_)
+    shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_)
         {__f.__state_ = nullptr;}
     _LIBCPP_INLINE_VISIBILITY
-    shared_future(shared_future&& __rhs) : __state_(__rhs.__state_)
+    shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
         {__rhs.__state_ = nullptr;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~shared_future();
     shared_future& operator=(const shared_future& __rhs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    shared_future& operator=(shared_future&& __rhs)
+    shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
         {
             shared_future(std::move(__rhs)).swap(*this);
             return *this;
@@ -2378,14 +2368,14 @@ public:
 
     // retrieving the value
     _LIBCPP_INLINE_VISIBILITY
-    _R& get() const {return __state_->copy();}
+    _Rp& get() const {return __state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
@@ -2401,16 +2391,16 @@ public:
             {return __state_->wait_until(__abs_time);}
 };
 
-template <class _R>
-shared_future<_R&>::~shared_future()
+template <class _Rp>
+shared_future<_Rp&>::~shared_future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
-template <class _R>
-shared_future<_R&>&
-shared_future<_R&>::operator=(const shared_future& __rhs)
+template <class _Rp>
+shared_future<_Rp&>&
+shared_future<_Rp&>::operator=(const shared_future& __rhs)
 {
     if (__rhs.__state_)
         __rhs.__state_->__add_shared();
@@ -2427,23 +2417,23 @@ class _LIBCPP_VISIBLE shared_future<void>
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    shared_future() : __state_(nullptr) {}
+    shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
         {if (__state_) __state_->__add_shared();}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    shared_future(future<void>&& __f) : __state_(__f.__state_)
+    shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_)
         {__f.__state_ = nullptr;}
     _LIBCPP_INLINE_VISIBILITY
-    shared_future(shared_future&& __rhs) : __state_(__rhs.__state_)
+    shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
         {__rhs.__state_ = nullptr;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~shared_future();
     shared_future& operator=(const shared_future& __rhs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    shared_future& operator=(shared_future&& __rhs)
+    shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
         {
             shared_future(std::move(__rhs)).swap(*this);
             return *this;
@@ -2455,11 +2445,11 @@ public:
     void get() const {__state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __state_ != nullptr;}
+    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
@@ -2475,28 +2465,28 @@ public:
             {return __state_->wait_until(__abs_time);}
 };
 
-template <class _R>
+template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-swap(shared_future<_R>& __x, shared_future<_R>& __y)
+swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
-template <class _R>
+template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
-shared_future<_R>
-future<_R>::share()
+shared_future<_Rp>
+future<_Rp>::share()
 {
-    return shared_future<_R>(_VSTD::move(*this));
+    return shared_future<_Rp>(_VSTD::move(*this));
 }
 
-template <class _R>
+template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
-shared_future<_R&>
-future<_R&>::share()
+shared_future<_Rp&>
+future<_Rp&>::share()
 {
-    return shared_future<_R&>(_VSTD::move(*this));
+    return shared_future<_Rp&>(_VSTD::move(*this));
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES