[libc++] Fix LWG3422 "Issues of seed_seq's constructors"

[• Quuxplusone]

Summary

https://cplusplus.github.io/LWG/issue3422

Also add a static_assert to check the "Mandates:" on the
iterator-pair constructor. Oddly, the InputIterator parameter
itself is merely preconditioned, not constrained, to satisfy the
input iterator requirements.

Also drive-by rename init to __init.

[Mordante]

LGTM!

libcxx/include/__random/seed_seq.h

37–38

Please include __nullptr to make sure this is available.

[• Quuxplusone]

@ldionne PTAL when you get a chance.

libcxx/include/__random/seed_seq.h

37–38

Actually this is under #ifndef _LIBCPP_CXX03_LANG so it should be fine. (I'm not sure we would #include <__nullptr> even if it weren't, but I've raised that tangent over on the Discord.)

[Mordante]

libcxx/include/__random/seed_seq.h

37–38

Good point. I think it would be good to do it when using C++03. So I retract my comment. So I'm happy with the current state of this patch.

[ldionne]

LGTM with suggestions implemented.

libcxx/include/__random/seed_seq.h

36

Are we already testing this noexcept-ness? If not, please add a simple test for that.

82

Can we get a libc++ specific .verify.cpp test for this diagnostic?

[• Quuxplusone]

Add an ASSERT_NOEXCEPT.
Add a .verify.cpp test — but, yuck, it produces an extra error message after the nice one; anything we can/should do about this @ldionne?
Drive-by uglify init to __init; I don't see where the init name came from, and it's private, so I think it's fair game to uglify.

[ldionne]

In D117962#3267049, @Quuxplusone wrote:

Add a .verify.cpp test — but, yuck, it produces an extra error message after the nice one; anything we can/should do about this @ldionne?

Yeah, that's annoying, but I think the solution you have right now is OK. Otherwise, in other places, I've also used something like this:

// This test checks that we static_assert inside std::atomic<T> when T
// is not trivially copyable, however Clang will sometimes emit additional
// errors while trying to instantiate the rest of std::atomic<T>.
// We silence those to make the test more robust.
// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error

Obviously you'd want to rephrase it not for atomic.

libcxx/docs/Status/Cxx2bIssues.csv

 `3121 <https://wg21.link/LWG3121>`__,"``tuple`` constructor constraints for ``UTypes&&...`` overloads","October 2021","",""
 `3123 <https://wg21.link/LWG3123>`__,"``duration`` constructor from representation shouldn't be effectively non-throwing","October 2021","","","|chrono|"
 `3146 <https://wg21.link/LWG3146>`__,"Excessive unwrapping in ``std::ref/cref``","October 2021","",""
 `3152 <https://wg21.link/LWG3152>`__,"``common_type`` and ``common_reference`` have flaws in common","October 2021","",""
 `3293 <https://wg21.link/LWG3293>`__,"``move_iterator operator+()`` has incorrect constraints","October 2021","","","|ranges|"
 `3361 <https://wg21.link/LWG3361>`__,"``safe_range<SomeRange&>`` case","October 2021","","","|ranges|"
 `3392 <https://wg21.link/LWG3392>`__,"``ranges::distance()`` cannot be used on a move-only iterator with a sized sentinel","October 2021","","","|ranges|"
 `3407 <https://wg21.link/LWG3407>`__,"Some problems with the wording changes of P1739R4","October 2021","","","|ranges|"
-`3422 <https://wg21.link/LWG3422>`__,"Issues of ``seed_seq``'s constructors","October 2021","",""
+`3422 <https://wg21.link/LWG3422>`__,"Issues of ``seed_seq``'s constructors","October 2021","|Complete|","14.0"
 `3470 <https://wg21.link/LWG3470>`__,"``convertible-to-non-slicing`` seems to reject valid case","October 2021","","","|ranges|"
 `3480 <https://wg21.link/LWG3480>`__,"``directory_iterator`` and ``recursive_directory_iterator`` are not C++20 ranges","October 2021","|Complete|","14.0","|ranges|"
 `3498 <https://wg21.link/LWG3498>`__,"Inconsistent ``noexcept``-specifiers for ``basic_syncbuf``","October 2021","",""
 `3535 <https://wg21.link/LWG3535>`__,"``join_view::iterator::iterator_category`` and ``::iterator_concept`` lie","October 2021","","","|ranges|"
 `3554 <https://wg21.link/LWG3554>`__,"``chrono::parse`` needs ``const charT*`` and ``basic_string_view<charT>`` overloads","October 2021","","","|chrono|"
 `3557 <https://wg21.link/LWG3557>`__,"The ``static_cast`` expression in ``convertible_to`` has the wrong operand","October 2021","",""
 `3559 <https://wg21.link/LWG3559>`__,"Semantic requirements of ``sized_range`` is circular","October 2021","","","|ranges|"
 `3560 <https://wg21.link/LWG3560>`__,"``ranges::equal`` and ``ranges::is_permutation`` should short-circuit for ``sized_ranges``","October 2021","","","|ranges|"

libcxx/include/__random/seed_seq.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TEMPLATE_VIS seed_seq
 {
 public:
     // types
     typedef uint32_t result_type;
 
-private:
-    vector<result_type> __v_;
-
-    template<class _InputIterator>
-        void init(_InputIterator __first, _InputIterator __last);
-public:
     // constructors
     _LIBCPP_INLINE_VISIBILITY
     seed_seq() _NOEXCEPT {}
 #ifndef _LIBCPP_CXX03_LANG
-    template<class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
-        seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());}
+    template<class _Tp, __enable_if_t<is_integral<_Tp>::value>* = nullptr>
+    seed_seq(initializer_list<_Tp> __il) {
+        __init(__il.begin(), __il.end());
+    }
 #endif // _LIBCPP_CXX03_LANG
 
     template<class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        seed_seq(_InputIterator __first, _InputIterator __last)
-             {init(__first, __last);}
+    seed_seq(_InputIterator __first, _InputIterator __last) {
+        static_assert(is_integral<typename iterator_traits<_InputIterator>::value_type>::value,
+            "Mandates: iterator_traits<InputIterator>::value_type is an integer type");
+        __init(__first, __last);
+    }
 
     // generating functions
     template<class _RandomAccessIterator>
         void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);
 
     // property functions
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const _NOEXCEPT {return __v_.size();}
     template<class _OutputIterator>
         _LIBCPP_INLINE_VISIBILITY
         void param(_OutputIterator __dest) const
             {_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
 
     seed_seq(const seed_seq&) = delete;
     void operator=(const seed_seq&) = delete;
 
     _LIBCPP_INLINE_VISIBILITY
     static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
+
+private:
+    template<class _InputIterator>
+    void __init(_InputIterator __first, _InputIterator __last);
+
+    vector<result_type> __v_;
 };
 
 template<class _InputIterator>
 void
-seed_seq::init(_InputIterator __first, _InputIterator __last)
+seed_seq::__init(_InputIterator __first, _InputIterator __last)
 {
     for (_InputIterator __s = __first; __s != __last; ++__s)
         __v_.push_back(*__s & 0xFFFFFFFF);
 }
 
 template<class _RandomAccessIterator>
 void
 seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
     if (__first != __last)

libcxx/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp

 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+  ASSERT_NOEXCEPT(std::seed_seq());
+  {
     std::seed_seq s;
     assert(s.size() == 0);
+  }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp

 // template<class InputIterator>
 //     seed_seq(InputIterator begin, InputIterator end);
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
+void test()
+{
   {
     unsigned a[5] = {5, 4, 3, 2, 1};
     std::seed_seq s(a, a+5);
     assert(s.size() == 5);
+
     unsigned b[5] = {0};
     s.param(b);
     assert(b[0] == 5);
     assert(b[1] == 4);
     assert(b[2] == 3);
     assert(b[3] == 2);
     assert(b[4] == 1);
+  }
+  {
+    // Test truncation to 32 bits
+    unsigned long long a[4] = {
+      0x1234000056780000uLL,
+      0x0000001234567800uLL,
+      0xFFFFFFFFFFFFFFFFuLL,
+      0x0000000180000000uLL,
+    };
+    std::seed_seq s(a, a+4);
+    assert(s.size() == 4);
+
+    unsigned b[4] = {0};
+    s.param(b);
+    assert(b[0] == 0x56780000u);
+    assert(b[1] == 0x34567800u);
+    assert(b[2] == 0xFFFFFFFFu);
+    assert(b[3] == 0x80000000u);
+  }
+#if TEST_STD_VER >= 11
+  {
+    // Test uniform initialization syntax (LWG 3422)
+    unsigned a[3] = {1, 2, 3};
+    std::seed_seq s{a, a+3};  // uniform initialization
+    assert(s.size() == 3);
+
+    unsigned b[3] = {0};
+    s.param(b);
+    assert(b[0] == 1);
+    assert(b[1] == 2);
+    assert(b[2] == 3);
+  }
+#endif // TEST_STD_VER >= 11
+}
+
+int main(int, char**)
+{
+  test();
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// <random>
+
+// class seed_seq;
+
+// template<class InputIterator>
+//   seed_seq(InputIterator begin, InputIterator end);
+// Mandates: iterator_traits<InputIterator>::value_type is an integer type.
+
+#include <random>
+
+void test()
+{
+  {
+    bool a[2] = {true, false};
+    std::seed_seq s(a, a+2); // OK
+  }
+  {
+    double a[2] = {1, 2};
+    std::seed_seq s(a, a+2); // expected-error@*:* {{Mandates: iterator_traits<InputIterator>::value_type is an integer type}}
+        // expected-error@*:* {{invalid operands to binary expression ('double' and 'unsigned int')}}
+  }
+}