[libc++] [P0935] [C++20] Eradicating unnecessarily explicit default constructors from the standard library.

[curdeius]

Summary

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0935r0.html

[curdeius]

libcxx/include/random

101–104

Please disregard modifications to stuff other than linear_congruential_engine.

[curdeius]

• Clean up. Test default seed.

[ldionne]

This is the same as D60422, which hasn't been updated in a while. I left some comments regarding how I suggest we create shared code to check for implicit default constructibility in that review. But I like the make_implicit<E>() trick.

@zoecarver I think you two should coordinate.

[curdeius]

• Implement: [rand.device] [rand.eng] [rand.dist.uni.int] [rand.dist.uni.real]

[curdeius]

@ldionne, 've discussed it with @zoecarver, and we decided that I'll take it over. It might take some time as there are many things to change (and test), but I'll appreciate your feedback.

My doubts:

• is using make_implicit really necessary or just test_convertible is enough? Using make_implicit tests as well that the default parameter is the correct one. It's not always possible (as in random_device for instance).
• name and location of make_implicit?
• I added as well test for ctors being explicit, and that was not tested before.

[curdeius]

One more question, lots of stuff in <random> tests are also run in c++03. Is it expected? Should I add guards to my additions (#if TEST_STD_VER >= 11)?

[curdeius]

• Use typedef for C++03 compatibility.
• [rand.dist.bern]
• [rand.dist.pois]
• [rand.dist.norm]
• [stringbuf]
• [istringstream]
• [stringbuf]
• [ostringstream]
• [stringstream]
• [re.results]
• [depr.strstreambuf]
• [depr.conversions.string]
• [depr.conversions.buffer]
• [queue] [priority.queue]
• [stack]

[curdeius]

• Fix [rand] in C++03 mode.

[ldionne]

In D91292#2424853, @curdeius wrote:

@ldionne, 've discussed it with @zoecarver, and we decided that I'll take it over. It might take some time as there are many things to change (and test), but I'll appreciate your feedback.

My doubts:

• is using make_implicit really necessary or just test_convertible is enough? Using make_implicit tests as well that the default parameter is the correct one. It's not always possible (as in random_device for instance).

I think we should test the value of the default argument when we can, as you did.

• name and location of make_implicit?

What you have looks OK to me.

• I added as well test for ctors being explicit, and that was not tested before.

Thank you!

In D91292#2425285, @curdeius wrote:

One more question, lots of stuff in <random> tests are also run in c++03. Is it expected? Should I add guards to my additions (#if TEST_STD_VER >= 11)?

We support <random> in C++03. It's one of those great things :-).

libcxx/test/support/make_implicit.h

26

C++11 is required only because you're using a brace initializer, right? Clang supports variadics and rvalue references even in C++03 mode, so I'm just checking.

[curdeius]

libcxx/test/support/make_implicit.h

26

Brace initializer, rvalue references and variadics, also std::forward but that could be just a static_cast. I can make it work for C++03 then.

[curdeius]

• Update status page.
• Generalize tests. Clean up.
• Remove requirement for > C++11 in make_implicit.h.

[curdeius]

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

[curdeius]

• Fix status page.

[ldionne]

In D91292#2427945, @curdeius wrote:

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

It was adopted as a paper, and it does *not* appear to have been voted as a DR. I found on the Rapperswill (2018) wiki motion page:

Motion 25
Move to apply to the C++ working paper the proposed wording in P0935R0 (Eradicating unnecessarily explicit default constructors from the standard library).

It doesn't appear to be applied as a DR, however the author himself was the one to change cppreference (looking at the history). @tcanens Do you have more context?

[tcanens]

In D91292#2440215, @ldionne wrote:

In D91292#2427945, @curdeius wrote:

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

It was adopted as a paper, and it does *not* appear to have been voted as a DR. I found on the Rapperswill (2018) wiki motion page:

Motion 25
Move to apply to the C++ working paper the proposed wording in P0935R0 (Eradicating unnecessarily explicit default constructors from the standard library).

It doesn't appear to be applied as a DR, however the author himself was the one to change cppreference (looking at the history). @tcanens Do you have more context?

LWG doesn't do official DRs like ever, so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

Both libstdc++ and MSVC implement P0935 unconditionally, so I suspect that I guessed correctly for this case.

[ldionne]

In D91292#2440252, @tcanens wrote:

LWG doesn't do official DRs like ever,

I'm not sure I follow. Aren't all LWG issues considered DRs and "back applied" to earlier standards, hence what we do in the libraries wrt LWG issues?

so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

I think it's misleading to call it a DR if it isn't one. I believe it would be more correct (and equally useful) to say that most implementations support it back in C++11, without using the word DR. It's a bit pedantic, but I think nothing is lost by being more precise.

Both libstdc++ and MSVC implement P0935 unconditionally, so I suspect that I guessed correctly for this case.

@curdeius In that case, I believe we should support it unconditionally as well. At worst, it's a very very small extension in older standards. That'll also simplify the implementation and the tests a bit.

[tcanens]

In D91292#2440351, @ldionne wrote:

In D91292#2440252, @tcanens wrote:

LWG doesn't do official DRs like ever,

I'm not sure I follow. Aren't all LWG issues considered DRs and "back applied" to earlier standards, hence what we do in the libraries wrt LWG issues?

LWG doesn't move issue resolutions as formal DRs the way CWG does. And not all issues are DRs - see, e.g., LWG2911 aka is_aggregate. I think the "file an issue if you want a paper back applied" process (as in LWG3494) is a fairly new invention.

so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

I think it's misleading to call it a DR if it isn't one. I believe it would be more correct (and equally useful) to say that most implementations support it back in C++11, without using the word DR. It's a bit pedantic, but I think nothing is lost by being more precise.

I think that adds unnecessary confusion and complexity, not to mention that ISO rules say that DRs only apply to the immediately previous standard so we still have similar problems with stuff that goes back farther than that. But I don't think this is the right place to discuss cppreference policy.

[ldionne]

In D91292#2440443, @tcanens wrote:

I think that adds unnecessary confusion and complexity, not to mention that ISO rules say that DRs only apply to the immediately previous standard so we still have similar problems with stuff that goes back farther than that. But I don't think this is the right place to discuss cppreference policy.

Indeed, I was just giving my opinion :-). cppreference is a great tool nonetheless.

@curdeius Let's implement this back to C++11 if that's OK by you. That way, we'll remove implementation divergence and simplify our life, and we'll also make cppreference tell the truth. 😁

[curdeius]

OK. No problem. That will be a nice cleanup indeed.

[curdeius]

• Apply to pre-C++20. That requires tho that the compiler supports delegated constructors in C++03 (it seems that clang does).

[curdeius]

• Revert for C++03 (no delegating constructors).

[curdeius]

• Fix C++03.

[curdeius]

Friendly ping.

[ldionne]

I didn't look again in detail, but I remember I was OK with the patch except for the question of whether to implement it as a DR. This has been settled now, so this LGTM. Thanks!

[curdeius]

Rebase to trigger CI to reverify.

libcxx/include/algorithm

public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
-    explicit uniform_int_distribution(result_type __a = 0,
-                                      result_type __b = numeric_limits<result_type>::max())
+#if _LIBCPP_STD_VER > 17
+    uniform_int_distribution() : uniform_int_distribution(0) {}
+    explicit uniform_int_distribution(
+        result_type __a, result_type __b = numeric_limits<result_type>::max())
+        : __p_(param_type(__a, __b)) {}
+#else
+    explicit uniform_int_distribution(
+        result_type __a = 0,
         : __p_(param_type(__a, __b)) {}
+#endif
     explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
     void reset() {}
 
     // generating functions
     template<class _URNG> result_type operator()(_URNG& __g)
         {return (*this)(__g, __p_);}
     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
 

libcxx/include/random

public:
     static constexpr result_type multiplier = a;
     static constexpr result_type increment = c;
     static constexpr result_type modulus = m;
     static constexpr result_type min() { return c == 0u ? 1u: 0u;}
     static constexpr result_type max() { return m - 1u;}
     static constexpr result_type default_seed = 1u;
 
     // constructors and seeding functions
-    explicit linear_congruential_engine(result_type s = default_seed);
+    explicit linear_congruential_engine(result_type s = default_seed);         // before C++20
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
+    explicit linear_congruential_engine(result_type s);                        // C++20
     template<class Sseq> explicit linear_congruential_engine(Sseq& q);
     void seed(result_type s = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
public:
     static constexpr result_type tempering_c = c;
     static constexpr size_t tempering_l = l;
     static constexpr result_type initialization_multiplier = f;
     static constexpr result_type min () { return 0; }
     static constexpr result_type max() { return 2^w - 1; }
     static constexpr result_type default_seed = 5489u;
 
     // constructors and seeding functions
-    explicit mersenne_twister_engine(result_type value = default_seed);
+    explicit mersenne_twister_engine(result_type s = default_seed);      // before C++20
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20
+    explicit mersenne_twister_engine(result_type s);                     // C++20
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
 
public:
     static constexpr size_t word_size = w;
     static constexpr size_t short_lag = s;
     static constexpr size_t long_lag = r;
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m-1; }
     static constexpr result_type default_seed = 19780503u;
 
     // constructors and seeding functions
-    explicit subtract_with_carry_engine(result_type value = default_seed);
+    explicit subtract_with_carry_engine(result_type value = default_seed);     // before C++20
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20
+    explicit subtract_with_carry_engine(result_type value);                    // C++20
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
public:
     // types
     typedef unsigned int result_type;
 
     // generator characteristics
     static constexpr result_type min() { return numeric_limits<result_type>::min(); }
     static constexpr result_type max() { return numeric_limits<result_type>::max(); }
 
     // constructors
-    explicit random_device(const string& token = "/dev/urandom");
+    explicit random_device(const string& token = implementation-defined); // before C++20
+    random_device() : random_device(implementation-defined) {}            // C++20
+    explicit random_device(const string& token);                          // C++20
 
     // generating functions
     result_type operator()();
 
     // property functions
     double entropy() const noexcept;
 
     // no copy functions
public:
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
     explicit uniform_int_distribution(IntType a = 0,
-                                    IntType b = numeric_limits<IntType>::max());
+                                      IntType b = numeric_limits<IntType>::max()); // before C++20
+    uniform_int_distribution() : uniform_int_distribution(0) {}                    // C++20
+    explicit uniform_int_distribution(IntType a,
+                                      IntType b = numeric_limits<IntType>::max()); // C++20
     explicit uniform_int_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
+    explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
+    uniform_real_distribution() : uniform_real_distribution(0.0) {}         // C++20
+    explicit uniform_real_distribution(RealType a, RealType b = 1.0);       // C++20
     explicit uniform_real_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
     static _LIBCPP_CONSTEXPR const result_type modulus = __m;
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
     static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
 
     // constructors and seeding functions
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit linear_congruential_engine(result_type __s) { seed(__s); }
+#else
     _LIBCPP_INLINE_VISIBILITY
-    explicit linear_congruential_engine(result_type __s = default_seed)
-        {seed(__s);}
+    explicit linear_congruential_engine(result_type __s = default_seed) {
+      seed(__s);
+    }
+#endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit linear_congruential_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __s = default_seed)
         {seed(integral_constant<bool, __m == 0>(),
public:
     static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
     static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
 
     // constructors and seeding functions
+#if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY
-    explicit mersenne_twister_engine(result_type __sd = default_seed)
-        {seed(__sd);}
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit mersenne_twister_engine(result_type __sd = default_seed) {
+      seed(__sd);
+    }
+#endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit mersenne_twister_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
         {seed(__q);}
     void seed(result_type __sd = default_seed);
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
public:
     static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
     static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
 
     // constructors and seeding functions
+#if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY
-    explicit subtract_with_carry_engine(result_type __sd = default_seed)
-        {seed(__sd);}
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit subtract_with_carry_engine(result_type __sd = default_seed) {
+      seed(__sd);
+    }
+#endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit subtract_with_carry_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd = default_seed)
         {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
public:
     static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
 
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
 
     // constructors
+#if _LIBCPP_STD_VER > 17
+    random_device() : random_device("/dev/urandom") {}
+    explicit random_device(const string& __token);
+#else
     explicit random_device(const string& __token = "/dev/urandom");
+#endif
     ~random_device();
 
     // generating functions
     result_type operator()();
 
     // property functions
     double entropy() const _NOEXCEPT;
 
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY
+    uniform_real_distribution() : uniform_real_distribution(0.0) {}
+    explicit uniform_real_distribution(result_type __a, result_type __b = 1.0)
+        : __p_(param_type(__a, __b)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY

libcxx/test/std/numerics/rand/rand.device/ctor.pass.cpp

 // XFAIL: with_system_cxx_lib=macosx10.9
 
 // UNSUPPORTED: libcpp-has-no-random-device
 
 // <random>
 
 // class random_device;
 
-// explicit random_device(const string& token = implementation-defined);
+// explicit random_device(const string& token = implementation-defined); // before C++20
+// random_device() : random_device(implementation-defined) {}            // C++20
+// explicit random_device(const string& token);                          // C++20
 
 // For the following ctors, the standard states: "The semantics and default
 // value of the token parameter are implementation-defined". Implementations
 // therefore aren't required to accept any string, but the default shouldn't
 // throw.
 
 #include <random>
 #include <system_error>
 #include <cassert>
 
 #if !defined(_WIN32)
 #include <unistd.h>
 #endif
 
 #include "test_macros.h"
-
+#include "test_convertible.h"
 
 bool is_valid_random_device(const std::string &token) {
 #if defined(_LIBCPP_USING_DEV_RANDOM)
   // Not an exhaustive list: they're the only tokens that are tested below.
   return token == "/dev/urandom" || token == "/dev/random";
 #else
   return token == "/dev/urandom";
 #endif
try {
     LIBCPP_ASSERT(false);
   } catch (const std::system_error&) {
   }
 #else
   ((void)token);
 #endif
 }
 
-
 int main(int, char**) {
   {
     std::random_device r;
   }
   {
     std::string token = "wrong file";
     check_random_device_invalid(token);
   }
// streams so that the descriptor '0' is available.
     ec = close(STDOUT_FILENO);
     assert(!ec);
     ec = close(STDERR_FILENO);
     assert(!ec);
     std::random_device r;
   }
 #endif // !defined(_WIN32)
 
+#if TEST_STD_VER > 17
+  static_assert(test_convertible<std::random_device>(), "");
+#else
+  static_assert(!test_convertible<std::random_device>(), "");
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class _IntType = int>
 // class uniform_int_distribution
 
 // explicit uniform_int_distribution(IntType a = 0,
-//                                   IntType b = numeric_limits<IntType>::max());
+//                                   IntType b = numeric_limits<IntType>::max()); // before C++20
+// uniform_int_distribution() : uniform_int_distribution(0) {}                    // C++20
+// explicit uniform_int_distribution(IntType a,
+//                                   IntType b = numeric_limits<IntType>::max()); // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#include "make_implicit.h"
+#include "test_convertible.h"
 
 int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
         D d;
         assert(d.a() == 0);
         assert(d.b() == std::numeric_limits<int>::max());
     }
     {
         typedef std::uniform_int_distribution<> D;
         D d(-6);
         assert(d.a() == -6);
         assert(d.b() == std::numeric_limits<int>::max());
     }
     {
         typedef std::uniform_int_distribution<> D;
         D d(-6, 106);
         assert(d.a() == -6);
         assert(d.b() == 106);
     }
 
+    {
+      using D = std::uniform_int_distribution<>;
+#if TEST_STD_VER > 17
+      static_assert(test_convertible<D>(), "");
+      assert(D(0) == make_implicit<D>());
+#else
+      static_assert(!test_convertible<D>(), "");
+#endif
+      static_assert(!test_convertible<D, int>(), "");
+      static_assert(!test_convertible<D, int, int>(), "");
+    }
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.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
-//
-//===----------------------------------------------------------------------===//
-
-// <random>
-
-// template<class RealType = double>
-// class uniform_real_distribution
-
-// explicit uniform_real_distribution(RealType a = 0,
-//                                    RealType b = 1);
-
-#include <random>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    {
-        typedef std::uniform_real_distribution<> D;
-        D d;
-        assert(d.a() == 0);
-        assert(d.b() == 1);
-    }
-    {
-        typedef std::uniform_real_distribution<> D;
-        D d(-6);
-        assert(d.a() == -6);
-        assert(d.b() == 1);
-    }
-    {
-        typedef std::uniform_real_distribution<> D;
-        D d(-6, 106);
-        assert(d.a() == -6);
-        assert(d.b() == 106);
-    }
-
-  return 0;
-}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_real_real.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
+//
+//===----------------------------------------------------------------------===//
+
+// <random>
+
+// template<class RealType = double>
+// class uniform_real_distribution
+
+// explicit uniform_real_distribution(RealType a = 0.0,
+//                                    RealType b = 1.0);             // before C++20
+// uniform_real_distribution() : uniform_real_distribution(0.0) {}   // C++20
+// explicit uniform_real_distribution(RealType a, RealType b = 1.0); // C++20
+
+#include <random>
+#include <cassert>
+
+#include "test_macros.h"
+#include "make_implicit.h"
+#include "test_convertible.h"
+
+int main(int, char**)
+{
+    {
+        typedef std::uniform_real_distribution<> D;
+        D d;
+        assert(d.a() == 0.0);
+        assert(d.b() == 1.0);
+    }
+    {
+        typedef std::uniform_real_distribution<> D;
+        D d(-6.5);
+        assert(d.a() == -6.5);
+        assert(d.b() == 1.0);
+    }
+    {
+        typedef std::uniform_real_distribution<> D;
+        D d(-6.9, 106.1);
+        assert(d.a() == -6.9);
+        assert(d.b() == 106.1);
+    }
+
+    {
+      using D = std::uniform_real_distribution<>;
+#if TEST_STD_VER > 17
+      static_assert(test_convertible<D>(), "");
+      assert(D(0) == make_implicit<D>());
+#else
+      static_assert(!test_convertible<D>(), "");
+#endif
+      static_assert(!test_convertible<D, double>(), "");
+      static_assert(!test_convertible<D, double, double>(), "");
+    }
+
+    return 0;
+}

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template <class UIntType, UIntType a, UIntType c, UIntType m>
 //   class linear_congruential_engine;
 
-// explicit linear_congruential_engine(result_type s = default_seed);
+// explicit linear_congruential_engine(result_type s = default_seed);         // before C++20
+// linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
+// explicit linear_congruential_engine(result_type s);                        // C++20
 
 // Serializing/deserializing the state of the RNG requires iostreams
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#include "make_implicit.h"
+#include "test_convertible.h"
+
+template <class T>
+std::string to_string(T const& e) {
+  std::ostringstream os;
+  os << e;
+  return os.str();
+}
 
 template <class T>
 void
 test1()
 {
     // c % m != 0 && s % m != 0
     {
         typedef std::linear_congruential_engine<T, 2, 3, 7> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 0> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 4> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
 }
 
 template <class T>
 void
 test2()
 {
     // c % m != 0 && s % m == 0
     {
         typedef std::linear_congruential_engine<T, 2, 3, 7> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 0> E;
         E e(0);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 4> E;
         E e(4);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
 }
 
 template <class T>
 void
 test3()
 {
     // c % m == 0 && s % m != 0
     {
         typedef std::linear_congruential_engine<T, 2, 0, 7> E;
         E e(3);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "3");
+        assert(to_string(e) == "3");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 0> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 4> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "3");
+        assert(to_string(e) == "3");
     }
 }
 
 template <class T>
 void
 test4()
 {
     // c % m == 0 && s % m == 0
     {
         typedef std::linear_congruential_engine<T, 2, 0, 7> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 0> E;
         E e(0);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 4> E;
         E e(8);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
 }
 
+#if TEST_STD_VER > 17
+template <class T>
+void test_implicit_ctor() {
+  using E = std::linear_congruential_engine<T, 2, 0, 7>;
+  assert(E(E::default_seed) == make_implicit<E>());
+}
+#endif
+
 int main(int, char**)
 {
     test1<unsigned short>();
     test1<unsigned int>();
     test1<unsigned long>();
     test1<unsigned long long>();
 
     test2<unsigned short>();
     test2<unsigned int>();
     test2<unsigned long>();
     test2<unsigned long long>();
 
     test3<unsigned short>();
     test3<unsigned int>();
     test3<unsigned long>();
     test3<unsigned long long>();
 
     test4<unsigned short>();
     test4<unsigned int>();
     test4<unsigned long>();
     test4<unsigned long long>();
 
+    {
+      typedef std::linear_congruential_engine<unsigned short, 2, 0, 7> E;
+#if TEST_STD_VER > 17
+      static_assert(test_convertible<E>(), "");
+      test_implicit_ctor<unsigned short>();
+#else
+      static_assert(!test_convertible<E>(), "");
+#endif
+      static_assert(!test_convertible<E, unsigned short>(), "");
+    }
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template <class UIntType, size_t w, size_t n, size_t m, size_t r,
 //           UIntType a, size_t u, UIntType d, size_t s,
 //           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
 // class mersenne_twister_engine;
 
-// explicit mersenne_twister_engine(result_type s = default_seed);
+// explicit mersenne_twister_engine(result_type s = default_seed);      // before C++20
+// mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20
+// explicit mersenne_twister_engine(result_type s);                     // C++20
 
 // Serializing/deserializing the state of the RNG requires iostreams
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#include "make_implicit.h"
+#include "test_convertible.h"
+
+template <class T>
+std::string
+to_string(T const &e)
+{
+    std::ostringstream os;
+    os << e;
+    return os.str();
+}
 
 void
 test1()
 {
     const char* a = "0 1 1812433255 1900727105 1208447044 2481403966 4042607538 337614300 "
     "3232553940 1018809052 3202401494 1775180719 3192392114 594215549 184016991 "
     "829906058 610491522 3879932251 3139825610 297902587 4075895579 2943625357 "
     "3530655617 1423771745 2135928312 2891506774 1066338622 135451537 933040465 "
test1()
     "1708182873 2796363264 292154131 4280019913 1102652157 1185393592 "
     "1494991690 4270076389 2384840717 425785147 2385321880 317514772 3926962743 "
     "392176856 3465421709 1878853468 122662664 2958252160 1858961315 2244939588 "
     "2361884409 2860936803 683833250 3291277128 1686857206 1112632275 "
     "1200680507 3342928196 2677058150 939442136 3407104669 2906783932 "
     "3668048733 2030009470 1910839172 1234925283 3575831445 123595418 "
     "2362440495 3048484911 1796872496";
     std::mt19937 e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
 }
 
 void
 test2()
 {
     const char* a = "0 1 6364136223846793007 13885033948157127961 "
     "15324573939901584278 12737837167382305846 15195339788985155882 "
     "6554113247712070460 17235932740818599105 13007415075556305955 "
test2()
     "6533591052147596041 1308401457054431629 17488144120120152559 "
     "14075631579093810083 4015705597302725704 6833920126528811473 "
     "5095302940809114298 8312250184258072842 15770605014574863643 "
     "14091690436120485477 15763282477731738396 16394237160547425954 "
     "5066318118328746621 13140493775100916989 6371148952471982853 "
     "15150289760867914983 4931341382074091848 12635920082410445322 "
     "8498109357807439006 14836776625250834986";
     std::mt19937_64 e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
+}
+
+#if TEST_STD_VER > 17
+template <class E>
+void test_implicit_ctor() {
+  assert(E(E::default_seed) == make_implicit<E>());
 }
+#endif
 
 int main(int, char**)
 {
     test1();
     test2();
+#if TEST_STD_VER > 17
+    static_assert(test_convertible<std::mt19937>(), "");
+    static_assert(test_convertible<std::mt19937_64>(), "");
+    test_implicit_ctor<std::mt19937>();
+    test_implicit_ctor<std::mt19937_64>();
+#else
+    static_assert(!test_convertible<std::mt19937>(), "");
+    static_assert(!test_convertible<std::mt19937_64>(), "");
+#endif
+    static_assert(!test_convertible<std::mt19937, uint_fast32_t>(), "");
+    static_assert(!test_convertible<std::mt19937_64, uint_fast64_t>(), "");
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class UIntType, size_t w, size_t s, size_t r>
 // class subtract_with_carry_engine;
 
-// explicit subtract_with_carry_engine(result_type s = default_seed);
+// explicit subtract_with_carry_engine(result_type s = default_seed);         // before C++20
+// subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20
+// explicit subtract_with_carry_engine(result_type s);                        // C++20
 
 // Serializing/deserializing the state of the RNG requires iostreams
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#include "make_implicit.h"
+#include "test_convertible.h"
+
+template <class T>
+std::string
+to_string(T const &e)
+{
+    std::ostringstream os;
+    os << e;
+    return os.str();
+}
 
 void
 test1()
 {
     const char* a = "15136306 8587749 2346244 16479026 15515802 9510553 "
     "16090340 14501685 13839944 10789678 11581259 9590790 5840316 5953700 "
     "13398366 8134459 16629731 6851902 15583892 1317475 4231148 9092691 "
     "5707268 2355175 0";
     std::ranlux24_base e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
 }
 
 void
 test2()
 {
     const char* a = "10880375256626 126660097854724 33643165434010 "
     "78293780235492 179418984296008 96783156950859 238199764491708 "
     "34339434557790 155299155394531 29014415493780 209265474179052 "
     "263777435457028 0";
     std::ranlux48_base e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
+}
+
+#if TEST_STD_VER > 17
+template <class E>
+void test_implicit_ctor() {
+  assert(E(E::default_seed) == make_implicit<E>());
 }
+#endif
 
 int main(int, char**)
 {
     test1();
     test2();
+#if TEST_STD_VER > 17
+    static_assert(test_convertible<std::ranlux24_base>(), "");
+    static_assert(test_convertible<std::ranlux48_base>(), "");
+    test_implicit_ctor<std::ranlux24_base>();
+    test_implicit_ctor<std::ranlux48_base>();
+#else
+    static_assert(!test_convertible<std::ranlux24_base>(), "");
+    static_assert(!test_convertible<std::ranlux24_base, uint_fast32_t>(), "");
+    static_assert(!test_convertible<std::ranlux48_base>(), "");
+    static_assert(!test_convertible<std::ranlux48_base, uint_fast64_t>(), "");
+#endif
 
   return 0;
 }

libcxx/test/support/make_implicit.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_MAKE_IMPLICIT_H
+#define SUPPORT_MAKE_IMPLICIT_H
+
+// "make_implicit<Tp>(Args&&... args)" is a function to construct 'Tp'
+// from 'Args...' using implicit construction.
+
+#include <utility>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER < 11
+#error make_implicit.h requires C++11 or newer
+#endif
+
+template <class T, class... Args>
+T make_implicit(Args&&... args) {
+  return {std::forward<Args>(args)...};
+}
+
+#endif // SUPPORT_MAKE_IMPLICIT_H