Second part of P1227R2 - Signed ssize() functions, unsigned size() functions

[mclow.lists]

Summary

Implement the global function std::ssize

[mclow.lists]

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

25

I can remove this test for C++14

[mclow.lists]

Made bits of the test more explicit.

[ldionne]

libcxx/include/iterator

1868

Is there a reason for making this inline? Templates are already inline by default.

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

42

Why is this commented? I think we can have a libc++ specific check here because our std::size(Container const&) is marked noexcept conditionally on the noexcept-ness of container.size().

59

ditto

[mclow.lists]

libcxx/include/iterator

1868

Nope; I'll remove it.

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

42

I just took this from the std::size tests. I can make them both check.

[mclow.lists]

Update based on Louis' comments.
Make std::ssize conditionally noexcept.
Leave it as inline _LIBCPP_INLINE_VISIBILITY

Update the ssize tests to check the noexcept-ness.
Update the size tests to check the noexcept-ness.

libcxx/include/iterator

1868

All "the rest of these" (size,data, empty, etc) are inline _LIBCPP_INLINE_VISIBILITY. I left these new ones the same.

[mclow.lists]

Committed as revision 354950

libcxx/include/iterator

 // 24.8, container access:
 template <class C> constexpr auto size(const C& c) -> decltype(c.size());         // C++17
 template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17
+
+template <class C> constexpr auto ssize(const C& c)
+    -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;               // C++20
+template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20
+
 template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());       // C++17
 template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;  // C++17
 template <class E> constexpr bool empty(initializer_list<E> il) noexcept;         // C++17

 inline _LIBCPP_INLINE_VISIBILITY
 constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Cont>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr auto ssize(const _Cont& __c)
+_NOEXCEPT_(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size())))
+->                              common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>
+{ return            static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()); }
+
+template <class _Tp, ptrdiff_t _Sz>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; }
+#endif
+
 template <class _Cont>
 _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 constexpr auto empty(const _Cont& __c)

libcxx/test/std/iterators/iterator.container/size.pass.cpp

 
 
 template<typename C>
-void test_const_container( const C& c )
+void test_container( C& c)
 {
 //  Can't say noexcept here because the container might not be
     assert ( std::size(c)   == c.size());
 }
 
-template<typename T>
-void test_const_container( const std::initializer_list<T>& c)
+template<typename C>
+void test_const_container( const C& c )
 {
-//  ASSERT_NOEXCEPT(std::size(c));
-//  For some reason, there isn't a std::size() for initializer lists
+//  Can't say noexcept here because the container might not be
     assert ( std::size(c)   == c.size());
 }
 
-template<typename C>
-void test_container( C& c)
+template<typename T>
+void test_const_container( const std::initializer_list<T>& c)
 {
-//  Can't say noexcept here because the container might not be
+    LIBCPP_ASSERT_NOEXCEPT(std::size(c)); // our std::size is conditionally noexcept
     assert ( std::size(c)   == c.size());
 }
 
 template<typename T>
 void test_container( std::initializer_list<T>& c )
 {
-//  ASSERT_NOEXCEPT(std::size(c));
-//  For some reason, there isn't a std::size() for initializer lists
+    LIBCPP_ASSERT_NOEXCEPT(std::size(c)); // our std::size is conditionally noexcept
     assert ( std::size(c)   == c.size());
 }
 

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

 
 
 struct short_container {
-    uint16_t size() const { return 60000; }
+    uint16_t size() const { return 60000; } // not noexcept
     };
 
+
+
 template<typename C>
-void test_const_container(const C& c)
+void test_container(C& c)
 {
 //  Can't say noexcept here because the container might not be
     static_assert( std::is_signed_v<decltype(std::ssize(c))>, "");
     assert ( std::ssize(c)   == static_cast<decltype(std::ssize(c))>(c.size()));
 }
 
-template<typename T>
-void test_const_container(const std::initializer_list<T>& c)
+template<typename C>
+void test_const_container(const C& c)
 {
-//  ASSERT_NOEXCEPT(std::size(c));
+//  Can't say noexcept here because the container might not be
     static_assert( std::is_signed_v<decltype(std::ssize(c))>, "");
-//  For some reason, there isn't a std::size() for initializer lists, so it uses the generic one
     assert ( std::ssize(c)   == static_cast<decltype(std::ssize(c))>(c.size()));
 }
 
-template<typename C>
-void test_container(C& c)
+template<typename T>
+void test_const_container(const std::initializer_list<T>& c)
 {
-//  Can't say noexcept here because the container might not be
+    LIBCPP_ASSERT_NOEXCEPT(std::ssize(c)); // our std::ssize is conditionally noexcept
     static_assert( std::is_signed_v<decltype(std::ssize(c))>, "");
     assert ( std::ssize(c)   == static_cast<decltype(std::ssize(c))>(c.size()));
 }

 template<typename T>
 void test_container(std::initializer_list<T>& c)
 {
-//  ASSERT_NOEXCEPT(std::size(c));
-//  For some reason, there isn't a std::size() for initializer lists, so it uses the generic one
+    LIBCPP_ASSERT_NOEXCEPT(std::ssize(c)); // our std::ssize is conditionally noexcept
     static_assert( std::is_signed_v<decltype(std::ssize(c))>, "");
     assert ( std::ssize(c)   == static_cast<decltype(std::ssize(c))>(c.size()));
 }

 void test_const_array(const T (&array)[Sz])
 {
     ASSERT_NOEXCEPT(std::ssize(array));
+    static_assert( std::is_signed_v<decltype(std::ssize(array))>, "");
     assert ( std::ssize(array) == Sz );
 }
 

     static_assert( std::numeric_limits<                   decltype(std::ssize(sc))>::max()  > 60000, "");
     static_assert( std::numeric_limits<std::make_signed_t<decltype(std:: size(sc))>>::max() < 60000, "");
     assert (std::ssize(sc) == 60000);
+    LIBCPP_ASSERT_NOT_NOEXCEPT(std::ssize(sc));
     
   return 0;
 }