[libc++] LWG3001: add `remove_extent_t` to `weak_ptr::element_type`.

[var-const]

Summary

Also fix a few places in the shared_ptr implementation where
element_type was passed to the __is_compatible helper. This could
result in remove_extent being applied twice to the pointer's template
type (first by the definition of element_type and then by the helper),
potentially leading to somewhat less readable error messages for some
incorrect code.

[var-const]

libcxx/include/__memory/shared_ptr.h

384–410

This is pretty verbose, but it seemed important to ensure no changes in behavior for each language version. Please let me know if you have any suggestions on how to improve this.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp

41–48

I copied this from a similar test for shared_ptr.

[jloser]

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp

34

Why not use ASSERT_SAME_TYPE to be consistent instead of mixed use of ASSERT_SAME_TYPE and std::is_same? BTW, you could use std::is_same_v since this block is C++17 code.

[ldionne]

Thanks for looking into this! Have a few comments but it LGTM in essence, once we've addressed the LWG issue backporting. I think this should simplify the patch a bit.

libcxx/include/__memory/shared_ptr.h

384–410

Per offline review: Since this is a LWG issue we're fixing, we normally apply it in all standard modes. So you can fix weak_ptr in C++17 and above in-place.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp

85

You'll want to change this to #if TEST_STD_VER > 14 per my comment about backporting LWG issues.

[• Quuxplusone]

libcxx/include/__memory/shared_ptr.h

384–410

It would be much simpler to just treat LWG3001 as a DR against C++17. The issue description of LWG3001 makes it very clear that the intent was always to remove_extent_t in C++17; that diff just got lost in the editorial shuffle. I'm not saying "do it," but I'm at least saying "I hope @ldionne tells you to do it." ;)

(Personally I would be interested in a followup PR that DR'ed the remove_extent_t change back to C++11 just for simplicity's sake, but I suppose there'd be no real justification for that.)

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp

41–48

In both places, I think it would be valuable to include test<int[2]>. We expect foo_ptr<int[][2]>::element_type to be int[2]. I could imagine someone accidentally flubbing it to int with a pretty simple typo (changing remove_extent into remove_all_extents).
If we have a similar test for unique_ptr<X>::element_type, this comment would apply there too.

[var-const]

Address feedback:

• apply the fix to C++17 as well, not just C++20;
• add a test case for a multidimensional array;
• use test helper macros where appropriate.

[var-const]

Thanks for the comments, everyone! PTAL.

libcxx/include/__memory/shared_ptr.h

384–410

Thanks! This is also exactly what @ldionne suggested.

I'm not sure if further backporting can be done without a proposal?

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp

34

Thanks for pointing it out, it's mostly because I copied it from a different file and didn't think to update it. Changed to use the macro both here and in the shared_ptr test this is copied from.

41–48

Thanks for the suggestion. I added this check to the body of main (adding the check to test doesn't immediately work because the ASSERT_SAME_TYPE(typename std::weak_ptr<T>::element_type, T) check presumes the type is not an array, and it seemed easier to test this separately rather than find a workaround).

The unique_ptr test has a different structure, and I'd also prefer to keep this patch focused on shared/weak pointers.

[ldionne]

Some minor nits, that should fix the tests. LGTM once CI is passing.

Thanks for looking into this!

libcxx/include/__memory/shared_ptr.h

384–410

Indeed, let's just DR to C++17. That's what we always do. There would be no precedent for DRing to C++11.

1326

libcxx/include/memory

529–531

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp

14–16

[var-const]

Actually apply this change to C++17

[• Quuxplusone]

LGTM at this point modulo all the >= 17 that need to be > 14, and that we should see buildkite passing successfully before landing this.

libcxx/include/__memory/shared_ptr.h

378

Please keep this as > 14. Even though _LIBCPP_STD_VER will never actually be set to "15", the intuition is that C++2b behaves more like 23 than like 20, C++1z (e.g. "C++15") behaves more like 17 than like 14, and so on. So we pretty consistently use _LIBCPP_STD_VER > x and TEST_STD_VER > x instead of >=.
Ditto line 422; ditto throughout (and also the tests, such as where Louis commented about it).

482

Pre-existing nit would be nice to fix: type= should be type =
(Also pre-existing: typename enable_if<x>::type could be updated to __enable_if_t<x>. But I recommend against fixing that in this PR.)

[ldionne]

In D112092#3076034, @Quuxplusone wrote:

LGTM at this point modulo all the >= 17 that need to be > 14, and that we should see buildkite passing successfully before landing this.

I'll mention that I actually suggested doing that to @var-const to see if it would fly with the other reviewers. We've definitely been using VER > n as a convention in libc++ and the test suite, that's one of the few places where we're pretty consistent. However, I've always found it a bit weird and IMO it would be more natural to use >=. @Quuxplusone Would you (or someone else lurking on this review) oppose to making such a change? If so, why?

This is 100% orthogonal to the actual review -- I suggest @var-const just reverts to using > for getting this patch landed, and we can settle on this question separately. I'm just curious to see where that discussion leads us.

[• Quuxplusone]

I see buildkite is green, but for the record, I'd like to see this PR updated with >-instead-of->= and wait for buildkite to pass on that version also, before landing.

libcxx/include/__memory/shared_ptr.h

378

@ldionne wrote:

We've definitely been using VER > n as a convention in libc++ and the test suite, that's one of the few places where we're pretty consistent. However, I've always found it a bit weird and IMO it would be more natural to use >=. @Quuxplusone Would you (or someone else lurking on this review) oppose to making such a change? If so, why?

First off, I agree with your proposal for this patch (which is "revert to > and take this discussion about conventions to a separate PR").
I also agree that it's often kind of inconvenient for the reader to mentally translate > 14 into "ah, this feature is new in C++17." I bet we can even find one or two historical bugs due to people getting that math wrong.
However, I believe my "intuitive explanation" above is pretty teachable. And any proposal to change the convention needs to come with a proposal of what to do about C++2b: Do you propose that we should start landing patches with >= 23 instead of > 20, and update the __config line that right now says

#    define _LIBCPP_STD_VER 21  // current year, or date of c++2b ratification

? Or do you propose that we do a massive mechanical updating of > 20 to >= 23 every three years? or what?
(Therefore I'm happy to stop talking about this here, and you can just ping me in the I-think-unlikely event that such a PR materializes.)

[Mordante]

libcxx/include/__memory/shared_ptr.h

378

I don't object against using >=, as long as we fix all occurrence in all of libc++ and not start mixing styles. Else it will lead to more confusion.

For the C++2b issue; I would prefer to then use C++23. The C++ committee has been using their 3 year release train for several iterations and they keep on schedule. If for some reason C++23 becomes C++24, it would be a trivial search for 23'and replace them with 24.

[var-const]

Replace >= 17 with > 14.

[var-const]

Fix preexisting nit

[var-const]

libcxx/include/__memory/shared_ptr.h

378

(I have reverted to using the > 14 form for this patch)

For what it's worth, it does seem to me like the current convention is slightly less readable -- while it's trivial in any _individual_ instance to mentally substitute 17 and above for > 14 (for example), it does seem to add some mental strain, however slight, when skimming through code.

I did some simple grepping (with queries like VER > 14 under libcxx/), and looking at the results, both forms are used quite frequently. The > form is somewhat more common:

>= 03: 0 occurrences
>= 11: 1245 occurences
>= 14: 210
>= 17: 85
>= 20: 20

> 03: 20
> 11: 475
> 14: 612
> 17: 733
> 20: 118

What's interesting is that the >= form is much more common for C++11, whereas > is more common for newer standards.

The idea to use the expected standard release date as a placeholder and update it if necessary seems like a reasonable approach to me, for what it's worth. The potential s/23/24 change, while it might be somewhat large in terms of delta, is mechanical and self-contained and shouldn't break any users (and, moreover, might not need to happen at all). The benefits, however, are having arguably slightly more readable code. Giving that the benefit is continuing while the cost is contained within a few one-time cleanups, it seems like a reasonable compromise.

[ldionne]

The CI failures are caused by an unrelated change which should have been fixed now. Feel free to commit as-is (or rebase onto main and re-upload to trigger the CI again if you want to be super super safe).

[var-const]

Rebase on main -- hopefully the CI will pass now.

[var-const]

Rebase again, this time actually including the commit that fixes the tests.

[var-const]

The CI passes now -- this should be good to merge.

libcxx/docs/Status/Cxx20Issues.csv

 "`2978 <https://wg21.link/LWG2978>`__","Hash support for pmr::string and friends","Albuquerque","",""
 "`2979 <https://wg21.link/LWG2979>`__","aligned_union should require complete object types","Albuquerque","|Complete|",""
 "`2980 <https://wg21.link/LWG2980>`__","Cannot compare_exchange empty pointers","Albuquerque","",""
 "`2981 <https://wg21.link/LWG2981>`__","Remove redundant deduction guides from standard library","Albuquerque","",""
 "`2982 <https://wg21.link/LWG2982>`__","Making size_type consistent in associative container deduction guides","Albuquerque","",""
 "`2988 <https://wg21.link/LWG2988>`__","Clause 32 cleanup missed one typename","Albuquerque","|Complete|","13.0"
 "`2993 <https://wg21.link/LWG2993>`__","reference_wrapper<T> conversion from T&&","Albuquerque","|Complete|","13.0"
 "`2998 <https://wg21.link/LWG2998>`__","Requirements on function objects passed to {``forward_``,}list-specific algorithms","Albuquerque","|Nothing To Do|",""
-"`3001 <https://wg21.link/LWG3001>`__","weak_ptr::element_type needs remove_extent_t","Albuquerque","",""
+"`3001 <https://wg21.link/LWG3001>`__","weak_ptr::element_type needs remove_extent_t","Albuquerque","|Complete|","14.0"
 "`3024 <https://wg21.link/LWG3024>`__","variant's copies must be deleted instead of disabled via SFINAE","Albuquerque","|Complete|",""
 "","","","",""
 "`2164 <https://wg21.link/LWG2164>`__","What are the semantics of ``vector.emplace(vector.begin(), vector.back())``\ ?","Jacksonville","|Complete|",""
 "`2243 <https://wg21.link/LWG2243>`__","``istream::putback``\  problem","Jacksonville","|Complete|",""
 "`2816 <https://wg21.link/LWG2816>`__","``resize_file``\  has impossible postcondition","Jacksonville","|Nothing To Do|",""
 "`2843 <https://wg21.link/LWG2843>`__","Unclear behavior of ``std::pmr::memory_resource::do_allocate()``\ ","Jacksonville","|Complete|",""
 "`2849 <https://wg21.link/LWG2849>`__","Why does ``!is_regular_file(from)``\  cause ``copy_file``\  to report a ""file already exists"" error?","Jacksonville","|Nothing To Do|",""
 "`2851 <https://wg21.link/LWG2851>`__","``std::filesystem``\  enum classes are now underspecified","Jacksonville","|Nothing To Do|",""

libcxx/include/__memory/shared_ptr.h

struct rebind
         typedef allocator<_Other> other;
     };
 };
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
 
 template<class _Tp, class _Up>
 struct __compatible_with
 #if _LIBCPP_STD_VER > 14
     : is_convertible<remove_extent_t<_Tp>*, remove_extent_t<_Up>*> {};
 #else
     : is_convertible<_Tp*, _Up*> {};
 #endif // _LIBCPP_STD_VER > 14
 
 template <class _Ptr, class = void>
 struct __is_deletable : false_type { };
 template <class _Ptr>
 struct __is_deletable<_Ptr, decltype(delete declval<_Ptr>())> : true_type { };
 
 template <class _Ptr, class = void>
 struct __is_array_deletable : false_type { };
 template <class _Ptr>
 struct __is_array_deletable<_Ptr, decltype(delete[] declval<_Ptr>())> : true_type { };
 
 template <class _Dp, class _Pt,
     class = decltype(declval<_Dp>()(declval<_Pt>()))>
 static true_type __well_formed_deleter_test(int);
 
 template <class, class>
 static false_type __well_formed_deleter_test(...);
 
 template <class _Dp, class _Pt>
 struct __well_formed_deleter : decltype(__well_formed_deleter_test<_Dp, _Pt>(0)) {};
 
 template<class _Dp, class _Tp, class _Yp>
 struct __shared_ptr_deleter_ctor_reqs
 {
     static const bool value = __compatible_with<_Tp, _Yp>::value &&
                               is_move_constructible<_Dp>::value &&
                               __well_formed_deleter<_Dp, _Tp*>::value;
 };
 
 #if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI)
 #  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((trivial_abi))
 #else
 #  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
 #endif
 
 template<class _Tp>
#endif
     template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
     template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr(const shared_ptr& __r) _NOEXCEPT;
     template<class _Yp>
         _LIBCPP_INLINE_VISIBILITY
         shared_ptr(const shared_ptr<_Yp>& __r,
-                   typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
+                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat>::type = __nat())
                        _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr(shared_ptr&& __r) _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY  shared_ptr(shared_ptr<_Yp>&& __r,
-                   typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
+                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat>::type = __nat())
                        _NOEXCEPT;
     template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
-                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type= __nat());
+                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat>::type = __nat());
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
     template<class _Yp>
         shared_ptr(auto_ptr<_Yp>&& __r,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
 #endif
     template <class _Yp, class _Dp>
         shared_ptr(unique_ptr<_Yp, _Dp>&&,
                    typename enable_if
#endif
 
     ~shared_ptr();
 
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
-            __compatible_with<_Yp, element_type>::value,
+            __compatible_with<_Yp, _Tp>::value,
             shared_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
-            __compatible_with<_Yp, element_type>::value,
+            __compatible_with<_Yp, _Tp>::value,
             shared_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp>&& __r);
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
     template<class _Yp>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
#endif
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(shared_ptr& __r) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void reset() _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
-            __compatible_with<_Yp, element_type>::value,
+            __compatible_with<_Yp, _Tp>::value,
             void
         >::type
         _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p);
     template<class _Yp, class _Dp>
         typename enable_if
         <
-            __compatible_with<_Yp, element_type>::value,
+            __compatible_with<_Yp, _Tp>::value,
             void
         >::type
         _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p, _Dp __d);
     template<class _Yp, class _Dp, class _Alloc>
         typename enable_if
         <
-            __compatible_with<_Yp, element_type>::value,
+            __compatible_with<_Yp, _Tp>::value,
             void
         >::type
         _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p, _Dp __d, _Alloc __a);
 
     _LIBCPP_INLINE_VISIBILITY
     element_type* get() const _NOEXCEPT {return __ptr_;}
     _LIBCPP_INLINE_VISIBILITY
private:
     template <class _Yp, class _Un>
         struct __shared_ptr_default_delete<_Yp[], _Un>
             : default_delete<_Yp[]> {};
 
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
 };
 
-#if _LIBCPP_STD_VER >= 17
+#if _LIBCPP_STD_VER > 14
 template<class _Tp>
 shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
 template<class _Tp, class _Dp>
 shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
 #endif
 
 template<class _Tp>
 inline
shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
-                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
+                            typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 template<class _Tp>
 inline
 shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = nullptr;
     __r.__cntrl_ = nullptr;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
-                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
+                            typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = nullptr;
     __r.__cntrl_ = nullptr;
 }
 
shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
-    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
+    __compatible_with<_Yp, _Tp>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT
 {
     shared_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 inline
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
-    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
+    __compatible_with<_Yp, _Tp>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
shared_ptr<_Tp>::reset() _NOEXCEPT
     shared_ptr().swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
-    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
+    __compatible_with<_Yp, _Tp>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p)
 {
     shared_ptr(__p).swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp>
 inline
 typename enable_if
 <
-    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
+    __compatible_with<_Yp, _Tp>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
 {
     shared_ptr(__p, __d).swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp, class _Alloc>
 inline
 typename enable_if
 <
-    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
+    __compatible_with<_Yp, _Tp>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
 {
     shared_ptr(__p, __d, __a).swap(*this);
 }
 
 //

 }
 
 #endif // _LIBCPP_NO_RTTI
 
 template<class _Tp>
 class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr
 {
 public:
+#if _LIBCPP_STD_VER > 14
+    typedef remove_extent_t<_Tp> element_type;
+#else
     typedef _Tp element_type;
+#endif
+
 private:
     element_type*        __ptr_;
     __shared_weak_count* __cntrl_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r,
-                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
+                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
                         _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr(weak_ptr const& __r) _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r,
-                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
+                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
                          _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr(weak_ptr&& __r) _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
-                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
+                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
                          _NOEXCEPT;
     ~weak_ptr();
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
-            is_convertible<_Yp*, element_type*>::value,
+            __compatible_with<_Yp, _Tp>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
-            is_convertible<_Yp*, element_type*>::value,
+            __compatible_with<_Yp, _Tp>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
 
     template<class _Yp>
         typename enable_if
         <
-            is_convertible<_Yp*, element_type*>::value,
+            __compatible_with<_Yp, _Tp>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(weak_ptr& __r) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT
         {return __cntrl_ < __r.__cntrl_;}
 
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
 };
 
-#if _LIBCPP_STD_VER >= 17
+#if _LIBCPP_STD_VER > 14
 template<class _Tp>
 weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
 #endif
 
 template<class _Tp>
 inline
 _LIBCPP_CONSTEXPR
 weak_ptr<_Tp>::weak_ptr() _NOEXCEPT
weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
-                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
+                        typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type)
                          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
-                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
+                        typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = nullptr;
     __r.__cntrl_ = nullptr;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
-                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
+                        typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = nullptr;
     __r.__cntrl_ = nullptr;
 }
 
weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
-    is_convertible<_Yp*, _Tp*>::value,
+    __compatible_with<_Yp, _Tp>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
-    is_convertible<_Yp*, _Tp*>::value,
+    __compatible_with<_Yp, _Tp>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
-    is_convertible<_Yp*, _Tp*>::value,
+    __compatible_with<_Yp, _Tp>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 

 weak_ptr<_Tp>::reset() _NOEXCEPT
 {
     weak_ptr().swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp>
 shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r,
-                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
+                            typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat>::type)
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
 {
     if (__cntrl_ == nullptr)
         __throw_bad_weak_ptr();
 }
 
 template<class _Tp>

libcxx/include/memory

 
 template<class E, class T, class Y, class D>
     basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, unique_ptr<Y, D> const& p);
 
 template<class T>
 class shared_ptr
 {
 public:
-    typedef T element_type;
+    typedef T element_type; // until C++17
+    typedef remove_extent_t<T> element_type; // since C++17
     typedef weak_ptr<T> weak_type; // C++17
 
     // constructors:
     constexpr shared_ptr() noexcept;
     template<class Y> explicit shared_ptr(Y* p);
     template<class Y, class D> shared_ptr(Y* p, D d);
     template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
     template <class D> shared_ptr(nullptr_t p, D d);
template<class T, class... Args>
     shared_ptr<T> make_shared(Args&&... args);
 template<class T, class A, class... Args>
     shared_ptr<T> allocate_shared(const A& a, Args&&... args);
 
 template<class T>
 class weak_ptr
 {
 public:
-    typedef T element_type;
+    typedef T element_type; // until C++17
+    typedef remove_extent_t<T> element_type; // since C++17
 
     // constructors
     constexpr weak_ptr() noexcept;
     template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept;
     weak_ptr(weak_ptr const& r) noexcept;
     template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept;
     weak_ptr(weak_ptr&& r) noexcept;                      // C++14
     template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept; // C++14
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template<class T> class shared_ptr
 // {
 // public:
-//     typedef T element_type;
+//     typedef T element_type; // until C++17
+//     typedef remove_extent_t<T> element_type; // since C++17
 //     typedef weak_ptr<T> weak_type; // C++17
 //     ...
 // };
 
 #include <memory>
+#include <type_traits>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER > 14
 template <typename T, typename = std::void_t<> >
 struct has_less : std::false_type {};
 
 template <typename T>

 template <class T>
 void test() {
   ASSERT_SAME_TYPE(typename std::shared_ptr<T>::element_type, T);
 #if TEST_STD_VER > 14
   ASSERT_SAME_TYPE(typename std::shared_ptr<T>::weak_type, std::weak_ptr<T>);
   static_assert(std::is_copy_constructible<std::shared_ptr<T> >::value, "");
   static_assert(std::is_copy_assignable<std::shared_ptr<T> >::value, "");
   static_assert(has_less<std::shared_ptr<T> >::value);
-  static_assert(
-      std::is_same<typename std::shared_ptr<T[]>::element_type, T>::value, "");
-  static_assert(
-      std::is_same<typename std::shared_ptr<T[8]>::element_type, T>::value, "");
+  ASSERT_SAME_TYPE(typename std::shared_ptr<T[]>::element_type, T);
+  ASSERT_SAME_TYPE(typename std::shared_ptr<T[8]>::element_type, T);
 #endif
 }
 
 int main(int, char**) {
   test<A>();
   test<B>();
   test<int>();
   test<char*>();
 
+#if TEST_STD_VER > 14
+  ASSERT_SAME_TYPE(typename std::shared_ptr<int[][2]>::element_type, int[2]);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
         }
         catch (std::bad_weak_ptr&)
         {
         }
     }
     assert(A::count == 0);
 #endif
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A[]> sp0(new A[8]);
+        std::weak_ptr<A[]> wp(sp0);
+        std::shared_ptr<const A[]> sp(wp);
+        assert(sp.use_count() == 2);
+        assert(sp.get() == sp0.get());
+        assert(A::count == 8);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template<class T> class weak_ptr
 // {
 // public:
-//     typedef T element_type;
+//     typedef T element_type; // until C++17
+//     typedef remove_extent_t<T> element_type; // since C++17
 //     ...
 // };
 
 #include <memory>
+#include <type_traits>
 
 #include "test_macros.h"
 
 struct A;  // purposefully incomplete
+struct B {
+  int x;
+  B() = default;
+};
+
+template <class T>
+void test() {
+  ASSERT_SAME_TYPE(typename std::weak_ptr<T>::element_type, T);
+#if TEST_STD_VER > 14
+  ASSERT_SAME_TYPE(typename std::weak_ptr<T[]>::element_type, T);
+  ASSERT_SAME_TYPE(typename std::weak_ptr<T[8]>::element_type, T);
+#endif
+}
 
 int main(int, char**)
 {
-    static_assert((std::is_same<std::weak_ptr<A>::element_type, A>::value), "");
+  test<A>();
+  test<B>();
+  test<int>();
+  test<char*>();
+
+#if TEST_STD_VER > 14
+  ASSERT_SAME_TYPE(typename std::weak_ptr<int[][2]>::element_type, int[2]);
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp

int main(int, char**)
         }
         assert(pA.use_count() == 1);
         assert(B::count == 1);
         assert(A::count == 1);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        const std::shared_ptr<A[]> p1(new A[8]);
+        assert(p1.use_count() == 1);
+        {
+            std::weak_ptr<const A[]> p2;
+            p2 = p1;
+            assert(A::count == 8);
+            assert(p2.use_count() == 1);
+            assert(p1.use_count() == 1);
+        }
+        assert(p1.use_count() == 1);
+        assert(A::count == 8);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // weak_ptr
 
 // template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r);
+// template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r);
 
 #include <memory>
 #include <type_traits>
+#include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
assert(A::count == 0);
             assert(pB.use_count() == 1);
         }
         assert(B::count == 1);
         assert(A::count == 1);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        const std::shared_ptr<A[]> ps(new A[8]);
+        const std::weak_ptr<A[]> p1(ps);
+        {
+            std::weak_ptr<const A[]> p2;
+            p2 = p1;
+            assert(A::count == 8);
+            assert(p2.use_count() == 1);
+            assert(p1.use_count() == 1);
+        }
+        assert(p1.use_count() == 1);
+        assert(A::count == 8);
+    }
+    assert(A::count == 0);
+
+    {
+        const std::shared_ptr<A[]> ps(new A[8]);
+        std::weak_ptr<A[]> p1(ps);
+        {
+            std::weak_ptr<const A[]> p2;
+            p2 = std::move(p1);
+            assert(A::count == 8);
+            assert(p2.use_count() == 1);
+        }
+        assert(A::count == 8);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp

assert(A::count == 0);
         }
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A[]> p1(new A[8]);
+        assert(p1.use_count() == 1);
+        assert(A::count == 8);
+        {
+            std::weak_ptr<const A[]> p2(p1);
+            assert(A::count == 8);
+            assert(p2.use_count() == 1);
+            assert(p1.use_count() == 1);
+        }
+        assert(p1.use_count() == 1);
+        assert(A::count == 8);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // weak_ptr
 
 // template<class Y> weak_ptr(const weak_ptr<Y>& r);
-// template<class Y> weak_ptr(weak_ptr<Y> &&r);
+// template<class Y> weak_ptr(weak_ptr<Y>&& r);
 
 #include <memory>
 #include <type_traits>
+#include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
assert(A::count == 0);
         std::shared_ptr<A> ps(new A);
         std::weak_ptr<A> pA = source(ps);
         std::weak_ptr<B> pB(std::move(pA));
         assert(pB.use_count() == 1);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A[]> ps(new A[8]);
+        std::weak_ptr<A[]> p1 = source(ps);
+        std::weak_ptr<const A[]> p2(p1);
+        assert(p2.use_count() == 1);
+    }
+    assert(A::count == 0);
+
+    {
+        std::shared_ptr<A[]> ps(new A[8]);
+        std::weak_ptr<A[]> p1 = source(ps);
+        std::weak_ptr<const A[]> p2(std::move(p1));
+        assert(p2.use_count() == 1);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }