Remove `auto_ptr` in C++17.

[mclow.lists]

Summary

N4190 removed auto_ptr from C++1z. (and other stuff)

Wrap all the auto_ptr bits in an #ifdef so they disappear when compiling with -std=c++1z or later.

Introduce a new configuration option, _LIBCPP_NO_REMOVE_AUTOPTR which allows user code to continue using auto_ptr in C++1z mode if desired.

Add a test for _LIBCPP_NO_REMOVE_AUTOPTR, and mark all the rest of the auto_ptr tests to XFAIL for c++1z

[EricWF]

A couple of comments.

1. there's probably a better way to state _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTO_PTR). Maybe _LIBCPP_HAS_NO_AUTO_PTR which __config defines if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_NO_REMOVE_AUTO_PTR).

2. // XFAIL c++1z is eventually going to be a pain to maintain. I'll try and come up with a better way to state this condition in the test suite.

[dblaikie]

NO_REMOVE seems like a strange way of saying it - is there existing
precedent for that naming/description? (rather than something like
_LIBCPP_PROVIDE_AUTOPTR ?

As for tests - XFAILing seems a bit general when there's really not much
value in running any of the tests anyway. REQUIRES, perhaps? (that does
bring the issue I assume Eric is alluding to forward a bit (I assume what
he's alluding to is that when we have c++2x then we'd have to say XFAIL
c++1z c++2x and so on - switching it around we /already/ have the problem
that we'd want the auto_ptr tests to REQUIRE c++11, c++14 or whatever)) &
maybe having an explicit test or two for the negative case (I would worry
that XFAIL would be too vague "this should fail somehow... "). But maybe
that's all unnecessary paranoia.

• Dave

[EricWF]

FYI I have a LIT change out for review that adds "// REQUIRES-ANY: [...]" which would be subtle for use in this patch.

http://reviews.llvm.org/D20757

[EricWF]

REQUIRES-ANY landed in r271468.

[EricWF]

include/memory

1962

I would love to have a semi-consistent naming scheme for macros which re-enable removed C++17 features. Maybe _LIBCPP_ENABLE_REMOVED_CXX17_FOO? I'l apply whatever naming scheme we decide on to the changes in D28172

2019

Comment on the #endif?

test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp

20

Please add // MODULES_DEFINES: _LIBCPP_NO_REMOVE_AUTOPTR

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp

16

Please use REQUIRES: c++98, c++03, c++11, c++14 instead of XFAIL: c++1z for two reasons:

1. The former is future proof to new standard dialects whereas the latter is not.
2. XFAIL should only be used on tests that fail due to a bug or missing compiler feature, not for tests which we expect to fail for well defined reasons.

[mclow.lists]

there's probably a better way to state _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTO_PTR).

There probably is; but remember, we want to make it so someone can -D_LIBCPP_NO_REMOVE_AUTO_PTR on the command-line and get this back.

I would love to have a semi-consistent naming scheme for macros which re-enable removed C++17 features. Maybe _LIBCPP_ENABLE_REMOVED_CXX17_FOO

I like this: I'm using _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR now.

test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp

26

D'oh! auto_ptr

[mclow.lists]

Updated the macro name.
Use REQUIRES-ALL
Found a couple more tests that needed to be updated.
Fixed the libcxx/test bit.

[mclow.lists]

Landed as r292986

include/memory

 ForwardIterator
 uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 
-template <class Y> struct auto_ptr_ref {};
+template <class Y> struct auto_ptr_ref {};      // removed in C++17
 
 template<class X>
-class auto_ptr
+class auto_ptr                                  // removed in C++17
 {
 public:
     typedef X element_type;

     template <class U, class E>
         unique_ptr(unique_ptr<U, E>&& u) noexcept;
     template <class U>
-        unique_ptr(auto_ptr<U>&& u) noexcept;
+        unique_ptr(auto_ptr<U>&& u) noexcept;       // removed in C++17
 
     // destructor
     ~unique_ptr();

     shared_ptr(shared_ptr&& r) noexcept;
     template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
     template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
-    template<class Y> shared_ptr(auto_ptr<Y>&& r);
+    template<class Y> shared_ptr(auto_ptr<Y>&& r);          // removed in C++17
     template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
     shared_ptr(nullptr_t) : shared_ptr() { }
 

     template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     shared_ptr& operator=(shared_ptr&& r) noexcept;
     template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);
-    template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r);
+    template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); // removed in C++17
     template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
 
     // modifiers:

 inline _LIBCPP_INLINE_VISIBILITY
 void return_temporary_buffer(_Tp* __p) _NOEXCEPT {::operator delete(__p);}
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
 template <class _Tp>
 struct auto_ptr_ref
 {

 public:
     typedef void element_type;
 };
+#endif
 
 template <class _T1, class _T2, bool = is_same<typename remove_cv<_T1>::type,
                                                      typename remove_cv<_T2>::type>::value,

                       >::type = __nat()) _NOEXCEPT
             : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY unique_ptr(auto_ptr<_Up>&& __p,
                 typename enable_if<

             : __ptr_(__p.release())
             {
             }
+#endif
 
         _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT
             {

     _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d)
         : __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {}
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
                 typename enable_if<

                                   >::type
         operator=(auto_ptr<_Up> __p)
             {reset(__p.release()); return *this;}
-
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY ~unique_ptr() {reset();}
 

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type= __nat());
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp>
         shared_ptr(auto_ptr<_Yp>&& __r,

         shared_ptr(auto_ptr<_Yp> __r,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
 #endif
+#endif
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Yp, class _Dp>
         shared_ptr(unique_ptr<_Yp, _Dp>&&,

         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp>&& __r);
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
     template<class _Yp>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if

             shared_ptr
         >::type&
         operator=(auto_ptr<_Yp>&& __r);
+#endif
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
     template<class _Yp>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if

         >::type
         operator=(auto_ptr<_Yp> __r);
 #endif
+#endif
     template <class _Yp, class _Dp>
         typename enable_if
         <

 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
 template<class _Tp>
 template<class _Yp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

     __enable_weak_this(__r.get());
     __r.release();
 }
+#endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>

     return *this;
 }
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
 template<class _Tp>
 template<class _Yp>
 inline

     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
+#endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>

 
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_NO_REMOVE_AUTOPTR)
 template<class _Tp>
 template<class _Yp>
 inline _LIBCPP_INLINE_VISIBILITY

     shared_ptr(__r).swap(*this);
     return *this;
 }
+#endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>

test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// template <class X>
+// class auto_ptr;
+//
+//  In C++17, auto_ptr has been removed.
+//  However, for backwards compatibility, if _LIBCPP_NO_REMOVE_AUTOPTR
+//  is defined before including <memory>, then auto_ptr will be restored.
+
+#define _LIBCPP_NO_REMOVE_AUTOPTR
+
+#include <memory>
+#include <type_traits>
+
+int main()
+{
+    std::shared_ptr<int> p;
+}

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp

 
 // auto_ptr& operator=(auto_ptr& a) throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp

 
 // auto_ptr(auto_ptr& a) throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp

 
 // template<class Y> auto_ptr& operator=(auto_ptr<Y>& a) throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp

 
 // auto_ptr(auto_ptr& a) throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp

 
 // explicit auto_ptr(X* p =0) throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp

 
 // auto_ptr& operator=(auto_ptr_ref<X> r) throw()
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp

 
 // auto_ptr(auto_ptr_ref<X> r) throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp

 
 // template<class Y> operator auto_ptr<Y>() throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp

 
 // template<class Y> operator auto_ptr_ref<Y>() throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp

 
 // X& operator*() const throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp

 
 // X& operator*() const throw();
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <cassert>
 

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp

 #include <memory>
 #include <cassert>
 
+// XFAIL: c++1z
+
 #include "../A.h"
 
 void

test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp

 #include <memory>
 #include <cassert>
 
+// XFAIL: c++1z
+
 #include "../A.h"
 
 void

test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp

 //   ...
 // };
 
+// XFAIL: c++1z
+
 #include <memory>
 #include <type_traits>