[libc++] Explicitly reject `uniform_int_distribution<bool>` and `<char>`.

[• Quuxplusone]

Summary

`uniform_int_distribution<T>` is UB unless `T` is one of the non-character,
non-boolean integer types (`short` or larger). However, libc++ has never
enforced this. D114129 accidentally made `uniform_int_distribution<bool>`
into an error. Make it now *intentionally* an error; and likewise for the
character types and all user-defined class and enum types; but permit
`__[u]int128_t` to continue working.

Apply the same static_assert to all the integer distributions.

[• Quuxplusone]

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

84–91 ↗

(On Diff #391171)

Before you ask: yeah, these error bounds are crazy ad-hoc. But:

• the test isn't "flaky": in the sense that the engine g will always produce the same random sequence, so our code for dist should always cook that sequence into something that satisfies these arbitrary error bounds, and if it ever changes so that the error bounds fail, then we can just go edit this test.
• the old test was way more ad-hoc: like, what even is std::abs((mean - x_mean) / x_mean) < 0.01? Dividing by the mean of the distribution? We're just lucky they never tried a distribution with a mean of zero. 😀

[jloser]

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

84–91 ↗

(On Diff #391171)

One of those "oh boy" moments when looking at the existing trunk code (e.g. mean of zero comment).

[ldionne]

Let's just *not* support uniform_int_distribution<bool>, and make it into a static_assert.

Also, the test improvements should be made as a different patch. probably before this one cause it is needed to test with a wide variety of types like you do (which is a good improvement BTW).

[• Quuxplusone]

Let's just *not* support uniform_int_distribution<bool>, and make it into a static_assert.

Works for me, but (1) I'll feel better once we hear from @leonardchan, and (2) what do you want to do about char, signed char, char16_t, etc.? Also disallow them via static_assert, I'd guess?

[ldionne]

In D114920#3167060, @Quuxplusone wrote:

Let's just *not* support uniform_int_distribution<bool>, and make it into a static_assert.

Works for me, but (1) I'll feel better once we hear from @leonardchan, and (2) what do you want to do about char, signed char, char16_t, etc.? Also disallow them via static_assert, I'd guess?

Yeah, I'd do the same. If something is library UB and it's easy to diagnose, I would diagnose it.

[• Quuxplusone]

Change the intent of this PR from "re-enable" to "explicitly reject".

[• Quuxplusone]

libcxx/include/__random/is_valid_inttype.h

21–40 ↗

(On Diff #392064)

I'm not thrilled about this helper or its placement/naming, but it seemed like the best option.
Incidentally, this also gives people a sneaky libc++ internal detail that they can (unsupportedly) specialize in order to re-enable the removed functionality for specific user-defined types.
Should this helper be named __libcpp_*?

[ldionne]

Couple of comments.

Also, I'm going to try this patch out on a significant code base just to confirm it doesn't result in crazy breakage -- requesting changes until that's done.

Ref for myself: 86111407&86111417

libcxx/include/__random/is_valid_inttype.h

21–40 ↗

(On Diff #392064)

Yeah, let's use __libcpp_*. I don't like that name, but I think it's worth doing it if it reduces the likelihood of users messing around with our internal details.

37 ↗

(On Diff #392064)

This is where we could document that we support this as an extension, in a comment.

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

13 ↗

(On Diff #392064)

Any appetite for improving tests for other random distributions like this? It's *much* better than what we had before.

[ldionne]

Okay, so I have some initial results of my investigation. I found some uses of uniform_int_distribution with things like uint8_t, char, and unsigned char. There was definitely some breakage, however nothing that seemed entirely unmanageable.

I say we go for it, but we definitely need to add a release note. Also, we'll want to sync up with some folks that build their code bases from libc++ trunk (like I think @thakis @rnk @phosek) or they might encounter issues. They should proof their code bases before we land this (or if that can't be done in a reasonable time frame, then they can revert this commit internally).

One thing we could do to make things easier would be to have the static_asserts in a different commit, that way folks could just revert that one locally until they have solved their problems.

[• Quuxplusone]

@ldionne: Makes perfect sense to me. Would you care to suggest wording for a release note? Perhaps

(API Changes)
The integer distributions ``binomial_distribution``, ``discrete_distribution``,
``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``,
and ``uniform_int_distribution`` now conform to the Standard by rejecting
template parameter types other than ``short``, ``int``, ``long``, ``long long``,
(as an extension) ``__int128_t``, and the unsigned versions thereof.
In particular, ``uniform_int_distribution<int8_t>`` is no longer supported.

Also, since "everything but the static_asserts" is really just "the test file," shall I go ahead and land the test-file change by itself, soonish?

[• Quuxplusone]

libcxx/include/__random/is_valid_inttype.h

21–40 ↗

(On Diff #392064)

Will rename to __libcpp_random_is_valid_inttype.

Also yuck, libcxx/benchmarks/vector_operations.bench.cpp uses uniform_int_distribution<char> in order to get random example data for its vectors. Maybe we should just support that. It would match libstdc++, too.

uniform_int_distribution<char/int8_t/uint8_t>: GCC accepts, MSVC rejects with static_assert.
uniform_int_distribution<bool>: GCC and MSVC both reject, with ugly template error message.

[ldionne]

In D114920#3177676, @Quuxplusone wrote:

@ldionne: Makes perfect sense to me. Would you care to suggest wording for a release note? Perhaps

(API Changes)
The integer distributions ``binomial_distribution``, ``discrete_distribution``,
``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``,
and ``uniform_int_distribution`` now conform to the Standard by rejecting
template parameter types other than ``short``, ``int``, ``long``, ``long long``,
(as an extension) ``__int128_t``, and the unsigned versions thereof.
In particular, ``uniform_int_distribution<int8_t>`` is no longer supported.

Yes, that sounds perfect to me.

Also, since "everything but the static_asserts" is really just "the test file," shall I go ahead and land the test-file change by itself, soonish?

Yes! You can do this as a NFC commit and repurpose this patch to be only the static asserts and the release note, and fixing the benchmarks.

libcxx/include/__random/is_valid_inttype.h

21–40 ↗

(On Diff #392064)

So basically we'd only exclude bool? IMO we should strive for strict conformance, however we should also write a half-page paper to support it for char and other small types cause it kind of makes sense.

[• Quuxplusone]

Add a release note.
Fix the benchmarks.
Scope-creep to [libc++] Explicitly reject URNG types with signed result_types (fixes https://github.com/llvm/llvm-project/issues/48965 ) while I'm here.

[ldionne]

Can we add libc++ specific tests to check that we properly diagnose those? One big .verify.cpp test for all the distributions would be great. LGTM apart from that.

[• Quuxplusone]

Rebase. Split out "Explicitly reject URNG types with signed result_types" into its own PR.
If CI on this part is green, I'll probably just land it on Monday, since it's been approved since forever.

[• Quuxplusone]

Add missing pragmas.

libcxx/benchmarks/GenerateInput.h

 
 
 inline char getRandomChar() {
     std::uniform_int_distribution<> LettersDist(0, LettersSize-1);
     return Letters[LettersDist(getRandomEngine())];
 }
 
 template <class IntT>
-inline IntT getRandomInteger(IntT Min = 0,
-                             IntT Max = std::numeric_limits<IntT>::max()) {
-    std::uniform_int_distribution<IntT> dist(Min, Max);
-    return dist(getRandomEngine());
+inline IntT getRandomInteger(IntT Min, IntT Max) {
+    std::uniform_int_distribution<unsigned long long> dist(Min, Max);
+    return static_cast<IntT>(dist(getRandomEngine()));
 }
 
 inline std::string getRandomString(std::size_t Len) {
     std::string str(Len, 0);
     std::generate_n(str.begin(), Len, &getRandomChar);
     return str;
 }
 
std::vector<IntT> getPipeOrganIntegerInputs(size_t N) {
     return v;
 }
 
 
 template <class IntT>
 std::vector<IntT> getRandomIntegerInputs(size_t N) {
     std::vector<IntT> inputs;
     for (size_t i=0; i < N; ++i) {
-        inputs.push_back(getRandomInteger<IntT>());
+        inputs.push_back(getRandomInteger<IntT>(0, std::numeric_limits<IntT>::max()));
     }
     return inputs;
 }
 
 inline std::vector<std::string> getDuplicateStringInputs(size_t N) {
     std::vector<std::string> inputs(N, getRandomString(1024));
     return inputs;
 }

libcxx/benchmarks/algorithms.partition_point.bench.cpp

std::array<I, 10> every_10th_percentile_N(I first, N n) {
   return res;
 }
 
 template <class IntT>
 struct TestIntBase {
   static std::vector<IntT> generateInput(size_t size) {
     std::vector<IntT> Res(size);
     std::generate(Res.begin(), Res.end(),
-                  [] { return getRandomInteger<IntT>(); });
+                  [] { return getRandomInteger<IntT>(0, std::numeric_limits<IntT>::max()); });
     return Res;
   }
 };
 
 struct TestInt32 : TestIntBase<std::int32_t> {
   static constexpr const char* Name = "TestInt32";
 };
 

libcxx/benchmarks/allocation.bench.cpp

static void BM_AllocateOnly(benchmark::State& st) {
   }
 }
 
 template <class AllocWrapper>
 static void BM_DeallocateOnly(benchmark::State& st) {
   const size_t alloc_size = st.range(0);
   const auto NumAllocs = st.max_iterations;
 
-  using PtrT = void*;
   std::vector<void*> Pointers(NumAllocs);
   for (auto& p : Pointers) {
     p = AllocWrapper::Allocate(alloc_size);
   }
 
   void** Data = Pointers.data();
   void** const End = Pointers.data() + Pointers.size();
   while (st.KeepRunning()) {

libcxx/docs/ReleaseNotes.rst

- Removed the nonstandard methods ``std::chrono::file_clock::to_time_t`` and
   and ``std::chrono::file_clock::to_sys``, which are specified in the Standard.
   If you are not using C++20, you should move to it.
 
 - The declarations of functions ``declare_reachable``, ``undeclare_reachable``, ``declare_no_pointers``,
   ``undeclare_no_pointers``, and ``get_pointer_safety`` have been removed not only from C++2b but
   from all modes. Their symbols are still provided by the dynamic library for the benefit of
   existing compiled code. All of these functions have always behaved as no-ops.
 
+- The integer distributions ``binomial_distribution``, ``discrete_distribution``,
+  ``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``,
+  and ``uniform_int_distribution`` now conform to the Standard by rejecting
+  template parameter types other than ``short``, ``int``, ``long``, ``long long``,
+  (as an extension) ``__int128_t``, and the unsigned versions thereof.
+  In particular, ``uniform_int_distribution<int8_t>`` is no longer supported.
+
 ABI Changes
 -----------
 
 - The C++17 variable templates ``is_error_code_enum_v`` and
   ``is_error_condition_enum_v`` are now of type ``bool`` instead of ``size_t``.
 
 - The C++03 emulation type for ``std::nullptr_t`` has been removed in favor of
   using ``decltype(nullptr)`` in all standard modes. This is an ABI break for

libcxx/include/CMakeLists.txt

set(files
   __random/exponential_distribution.h
   __random/extreme_value_distribution.h
   __random/fisher_f_distribution.h
   __random/gamma_distribution.h
   __random/generate_canonical.h
   __random/geometric_distribution.h
   __random/independent_bits_engine.h
   __random/is_seed_sequence.h
+  __random/is_valid.h
   __random/knuth_b.h
   __random/linear_congruential_engine.h
   __random/log2.h
   __random/lognormal_distribution.h
   __random/mersenne_twister_engine.h
   __random/negative_binomial_distribution.h
   __random/normal_distribution.h
   __random/piecewise_constant_distribution.h

libcxx/include/__random/bernoulli_distribution.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 _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template<class _URNG>
 inline
 bernoulli_distribution::result_type
 bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     uniform_real_distribution<double> __gen;
     return __gen(__g) < __p.p();
 }
 
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
 {

libcxx/include/__random/binomial_distribution.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 _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS binomial_distribution
 {
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __t_;
         double __p_;

 
 // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
 //           variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
 template<class _IntType>
 template<class _URNG>
 _IntType
 binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     if (__pr.__t_ == 0 || __pr.__p_ == 0)
         return 0;
     if (__pr.__p_ == 1)
         return __pr.__t_;
     uniform_real_distribution<double> __gen;
     double __u = __gen(__g) - __pr.__pr_;
     if (__u < 0)
         return __pr.__r0_;

libcxx/include/__random/cauchy_distribution.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 _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

 };
 
 template <class _RealType>
 template<class _URNG>
 inline
 _RealType
 cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     uniform_real_distribution<result_type> __gen;
     // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
     return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,

libcxx/include/__random/discrete_distribution.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 _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H
 
 #include <__algorithm/upper_bound.h>
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cstddef>
 #include <iosfwd>
 #include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS discrete_distribution
 {
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         vector<double> __p_;
     public:
discrete_distribution<_IntType>::param_type::probabilities() const
     return __p;
 }
 
 template<class _IntType>
 template<class _URNG>
 _IntType
 discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     uniform_real_distribution<double> __gen;
     return static_cast<_IntType>(
            _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
                                                               __p.__p_.begin());
 }
 
 template <class _CharT, class _Traits, class _IT>
 basic_ostream<_CharT, _Traits>&

libcxx/include/__random/exponential_distribution.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 _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/generate_canonical.h>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     return -_VSTD::log
                   (
                       result_type(1) -
                       _VSTD::generate_canonical<result_type,
                                        numeric_limits<result_type>::digits>(__g)
                   )
                   / __p.lambda();
 }

libcxx/include/__random/extreme_value_distribution.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 _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template<class _RealType>
 template<class _URNG>
 _RealType
 extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     return __p.a() - __p.b() *
          _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const extreme_value_distribution<_RT>& __x)

libcxx/include/__random/fisher_f_distribution.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 _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/gamma_distribution.h>
+#include <__random/is_valid.h>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
     gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
     return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,

libcxx/include/__random/gamma_distribution.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 _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/exponential_distribution.h>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     result_type __a = __p.alpha();
     uniform_real_distribution<result_type> __gen(0, 1);
     exponential_distribution<result_type> __egen;
     result_type __x;
     if (__a == 1)
         __x = __egen(__g);
     else if (__a > 1)
     {

libcxx/include/__random/geometric_distribution.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 _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/negative_binomial_distribution.h>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS geometric_distribution
 {
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         double __p_;
     public:

libcxx/include/__random/is_valid.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 _LIBCPP___RANDOM_IS_VALID_H
+#define _LIBCPP___RANDOM_IS_VALID_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// [rand.req.genl]/1.5:
+// The effect of instantiating a template that has a template type parameter
+// named IntType is undefined unless the corresponding template argument is
+// cv-unqualified and is one of short, int, long, long long, unsigned short,
+// unsigned int, unsigned long, or unsigned long long.
+
+template<class> struct __libcpp_random_is_valid_inttype : false_type {};
+template<> struct __libcpp_random_is_valid_inttype<short> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<int> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<long> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<long long> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<unsigned short> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<unsigned int> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<unsigned long> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<unsigned long long> : true_type {};
+
+#ifndef _LIBCPP_HAS_NO_INT128
+template<> struct __libcpp_random_is_valid_inttype<__int128_t> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {};
+#endif // _LIBCPP_HAS_NO_INT128
+
+// [rand.req.urng]/3:
+// A class G meets the uniform random bit generator requirements if G models
+// uniform_random_bit_generator, invoke_result_t<G&> is an unsigned integer type,
+// and G provides a nested typedef-name result_type that denotes the same type
+// as invoke_result_t<G&>.
+// (In particular, reject URNGs with signed result_types; our distributions cannot
+// handle such generator types.)
+
+template<class, class = void> struct __libcpp_random_is_valid_urng : false_type {};
+template<class _Gp> struct __libcpp_random_is_valid_urng<_Gp, __enable_if_t<
+    is_unsigned<typename _Gp::result_type>::value &&
+    _IsSame<decltype(declval<_Gp&>()()), typename _Gp::result_type>::value
+> > : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANDOM_IS_VALID_H

libcxx/include/__random/negative_binomial_distribution.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 _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/bernoulli_distribution.h>
 #include <__random/gamma_distribution.h>
+#include <__random/is_valid.h>
 #include <__random/poisson_distribution.h>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
 {
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __k_;
         double __p_;
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _IntType>
 template<class _URNG>
 _IntType
 negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     result_type __k = __pr.k();
     double __p = __pr.p();
     if (__k <= 21 * __p)
     {
         bernoulli_distribution __gen(__p);
         result_type __f = 0;
         result_type __s = 0;
         while (__s < __k)

libcxx/include/__random/normal_distribution.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 _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
operator>>(basic_istream<_CharT, _Traits>& __is,
                normal_distribution<_RT>& __x);
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     result_type _Up;
     if (_V_hot_)
     {
         _V_hot_ = false;
         _Up = _V_;
     }
     else
     {

libcxx/include/__random/piecewise_constant_distribution.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 _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
 
 #include <__algorithm/upper_bound.h>
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <iosfwd>
 #include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
piecewise_constant_distribution<_RealType>::param_type::param_type(
     __init();
 }
 
 template<class _RealType>
 template<class _URNG>
 _RealType
 piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     typedef uniform_real_distribution<result_type> _Gen;
     result_type __u = _Gen()(__g);
     ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                       __u) - __p.__areas_.begin() - 1;
     return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
 }
 
 template <class _CharT, class _Traits, class _RT>

libcxx/include/__random/piecewise_linear_distribution.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 _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
 
 #include <__algorithm/upper_bound.h>
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <iosfwd>
 #include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
piecewise_linear_distribution<_RealType>::param_type::param_type(
     __init();
 }
 
 template<class _RealType>
 template<class _URNG>
 _RealType
 piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     typedef uniform_real_distribution<result_type> _Gen;
     result_type __u = _Gen()(__g);
     ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                       __u) - __p.__areas_.begin() - 1;
     __u -= __p.__areas_[__k];
     const result_type __dk = __p.__densities_[__k];
     const result_type __dk1 = __p.__densities_[__k+1];
     const result_type __deltad = __dk1 - __dk;

libcxx/include/__random/poisson_distribution.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 _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/clamp_to_integral.h>
 #include <__random/exponential_distribution.h>
+#include <__random/is_valid.h>
 #include <__random/normal_distribution.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS poisson_distribution
 {
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         double __mean_;
         double __s_;
poisson_distribution<_IntType>::param_type::param_type(double __mean)
     }
 }
 
 template <class _IntType>
 template<class _URNG>
 _IntType
 poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     double __tx;
     uniform_real_distribution<double> __urd;
     if (__pr.__mean_ < 10)
     {
          __tx = 0;
         for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx)
             __p *= __urd(__urng);
     }

libcxx/include/__random/student_t_distribution.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 _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/gamma_distribution.h>
+#include <__random/is_valid.h>
 #include <__random/normal_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     gamma_distribution<result_type> __gd(__p.n() * .5, 2);
     return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const student_t_distribution<_RT>& __x)

libcxx/include/__random/uniform_int_distribution.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 _LIBCPP___RANDOM_UNIFORM_INT_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_UNIFORM_INT_DISTRIBUTION_H
 
 #include <__bits>
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/log2.h>
 #include <bit>
 #include <cstddef>
 #include <cstdint>
 #include <iosfwd>
 #include <limits>
 #include <type_traits>
 
for (size_t __k = __n0_; __k < __n_; ++__k)
             _Sp <<= __w0_ + 1;
         else
             _Sp = 0;
         _Sp += __u & __mask1_;
     }
     return _Sp;
 }
 
-template<class _IntType = int> // __int128_t is also supported as an extension here
+template<class _IntType = int>
 class uniform_int_distribution
 {
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
 public:
     // types
     typedef _IntType result_type;
 
     class param_type
     {
         result_type __a_;
         result_type __b_;

 };
 
 template<class _IntType>
 template<class _URNG>
 typename uniform_int_distribution<_IntType>::result_type
 uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), uint32_t,
                                  typename make_unsigned<result_type>::type>::type _UIntType;
     const _UIntType _Rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
     if (_Rp == 1)
         return __p.a();
     const size_t _Dt = numeric_limits<_UIntType>::digits;
     typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
     if (_Rp == 0)

libcxx/include/__random/uniform_real_distribution.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 _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/generate_canonical.h>
+#include <__random/is_valid.h>
 #include <iosfwd>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

 };
 
 template<class _RealType>
 template<class _URNG>
 inline
 typename uniform_real_distribution<_RealType>::result_type
 uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     return (__p.b() - __p.a())
         * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
         + __p.a();
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,

libcxx/include/module.modulemap

module __random {
       module exponential_distribution        { private header "__random/exponential_distribution.h" }
       module extreme_value_distribution      { private header "__random/extreme_value_distribution.h" }
       module fisher_f_distribution           { private header "__random/fisher_f_distribution.h" }
       module gamma_distribution              { private header "__random/gamma_distribution.h" }
       module generate_canonical              { private header "__random/generate_canonical.h" }
       module geometric_distribution          { private header "__random/geometric_distribution.h" }
       module independent_bits_engine         { private header "__random/independent_bits_engine.h" }
       module is_seed_sequence                { private header "__random/is_seed_sequence.h" }
+      module is_valid                        { private header "__random/is_valid.h" }
       module knuth_b                         { private header "__random/knuth_b.h" }
       module linear_congruential_engine      { private header "__random/linear_congruential_engine.h" }
       module log2                            { private header "__random/log2.h" }
       module lognormal_distribution          { private header "__random/lognormal_distribution.h" }
       module mersenne_twister_engine         { private header "__random/mersenne_twister_engine.h" }
       module negative_binomial_distribution  { private header "__random/negative_binomial_distribution.h" }
       module normal_distribution             { private header "__random/normal_distribution.h" }
       module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" }

libcxx/include/random

 #include <__random/exponential_distribution.h>
 #include <__random/extreme_value_distribution.h>
 #include <__random/fisher_f_distribution.h>
 #include <__random/gamma_distribution.h>
 #include <__random/generate_canonical.h>
 #include <__random/geometric_distribution.h>
 #include <__random/independent_bits_engine.h>
 #include <__random/is_seed_sequence.h>
+#include <__random/is_valid.h>
 #include <__random/knuth_b.h>
 #include <__random/linear_congruential_engine.h>
 #include <__random/log2.h>
 #include <__random/lognormal_distribution.h>
 #include <__random/mersenne_twister_engine.h>
 #include <__random/negative_binomial_distribution.h>
 #include <__random/normal_distribution.h>
 #include <__random/piecewise_constant_distribution.h>

libcxx/test/libcxx/diagnostics/detail.headers/random/is_valid.module.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/is_valid.h'}}
+#include <__random/is_valid.h>