Deny warnings in doctests

Author: pitdicker

src/distributions/mod.rs

@@ -187,7 +187,7 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 /// use rand::distributions::Uniform;
 ///
 /// let mut rng = thread_rng();
-/// let mut erased_rng: &mut RngCore = &mut rng;
+/// let erased_rng: &mut RngCore = &mut rng;
 /// let val: f32 = erased_rng.sample(Uniform);
 /// println!("f32 from [0,1): {}", val);
 /// ```

src/lib.rs

@@ -53,13 +53,21 @@
 //! to seed from a strong parent generator with [`from_rng`]:
 //! 
 //! ```
+//! # use rand::{Rng, Error};
 //! // seed with fresh entropy:
 //! use rand::{StdRng, NewRng};
 //! let mut rng = StdRng::new();
+//! # let v: u32 = rng.gen();
 //! 
 //! // seed from thread_rng:
 //! use rand::{SmallRng, SeedableRng, thread_rng};
-//! let mut rng = SmallRng::from_rng(thread_rng());
+//!
+//! # fn try_inner() -> Result<(), Error> {
+//! let mut rng = SmallRng::from_rng(thread_rng())?;
+//! # let v: u32 = rng.gen();
+//! # Ok(())
+//! # }
+//! # try_inner().unwrap()
 //! ```
 //! 
 //! In case you specifically want to have a reproducible stream of "random"
@@ -175,6 +183,7 @@
        html_root_url = "https://docs.rs/rand/0.5")]
 
 #![deny(missing_debug_implementations)]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 
 #![cfg_attr(not(feature="std"), no_std)]
 #![cfg_attr(all(feature="alloc", not(feature="std")), feature(alloc))]
@@ -292,11 +301,14 @@ pub trait Rand : Sized {
 /// Example:
 /// 
 /// ```rust
+/// # use rand::thread_rng;
 /// use rand::Rng;
 /// 
 /// fn foo<R: Rng + ?Sized>(rng: &mut R) -> f32 {
 ///     rng.gen()
 /// }
+///
+/// # let v = foo(&mut thread_rng());
 /// ```
 /// 
 /// # Iteration
@@ -345,7 +357,7 @@ pub trait Rng: RngCore {
     /// use rand::{thread_rng, Rng};
     /// 
     /// let mut arr = [0i8; 20];
-    /// thread_rng().try_fill(&mut arr[..]);
+    /// thread_rng().fill(&mut arr[..]);
     /// ```
     /// 
     /// [`fill_bytes`]: https://docs.rs/rand_core/0.1/rand_core/trait.RngCore.html#method.fill_bytes
@@ -433,6 +445,7 @@ pub trait Rng: RngCore {
     /// # Example
     ///
     /// ```
+    /// # #![allow(deprecated)]
     /// use rand::{thread_rng, Rng};
     ///
     /// let mut rng = thread_rng();
@@ -480,7 +493,7 @@ pub trait Rng: RngCore {
     /// # Example
     ///
     /// ```rust
-    /// #[allow(deprecated)]
+    /// # #![allow(deprecated)]
     /// use rand::{thread_rng, Rng};
     ///
     /// let mut rng = thread_rng();
@@ -520,7 +533,7 @@ pub trait Rng: RngCore {
     /// # Example
     ///
     /// ```rust
-    /// #[allow(deprecated)]
+    /// # #![allow(deprecated)]
     /// use rand::{thread_rng, Rng};
     ///
     /// let s: String = thread_rng().gen_ascii_chars().take(10).collect();
@@ -750,20 +763,23 @@ pub trait NewRng: SeedableRng {
     /// almost certainly be platform limitations or build issues, i.e. most
     /// applications targetting PC/mobile platforms should not need to worry
     /// about this failing.
-    /// 
+    ///
     /// If all entropy sources fail this will panic. If you need to handle
     /// errors, use the following code, equivalent aside from error handling:
-    /// 
+    ///
     /// ```rust
-    /// use rand::{Rng, StdRng, EntropyRng, SeedableRng, Error};
-    /// 
-    /// fn foo() -> Result<(), Error> {
-    ///     // This uses StdRng, but is valid for any R: SeedableRng
-    ///     let mut rng = StdRng::from_rng(EntropyRng::new())?;
-    ///     
-    ///     println!("random number: {}", rng.gen_range(1, 10));
-    ///     Ok(())
-    /// }
+    /// # use rand::Error;
+    /// use rand::{Rng, StdRng, EntropyRng, SeedableRng};
+    ///
+    /// # fn try_inner() -> Result<(), Error> {
+    /// // This uses StdRng, but is valid for any R: SeedableRng
+    /// let mut rng = StdRng::from_rng(EntropyRng::new())?;
+    ///
+    /// println!("random number: {}", rng.gen_range(1, 10));
+    /// # Ok(())
+    /// # }
+    ///
+    /// # try_inner().unwrap()
     /// ```
     fn new() -> Self;
 }
@@ -844,11 +860,13 @@ impl CryptoRng for StdRng {}
 /// Initializing `StdRng` with a random seed can be done using `NewRng`:
 ///
 /// ```
+/// # use rand::Rng;
 /// use rand::{NewRng, SmallRng};
 ///
 /// // Create small, cheap to initialize and fast RNG with a random seed.
 /// // The randomness is supplied by the operating system.
 /// let mut small_rng = SmallRng::new();
+/// # let v: u32 = small_rng.gen();
 /// ```
 ///
 /// When initializing a lot of `SmallRng`, using `thread_rng` can be more
@@ -930,6 +948,7 @@ pub fn weak_rng() -> XorShiftRng {
 /// # Example
 ///
 /// ```rust
+/// # #![allow(deprecated)]
 /// use rand::{thread_rng, sample};
 ///
 /// let mut rng = thread_rng();

src/prng/chacha.rs

@@ -108,6 +108,7 @@ impl ChaChaRng {
     /// # Examples
     ///
     /// ```rust
+    /// # #![allow(deprecated)]
     /// use rand::{RngCore, ChaChaRng};
     ///
     /// let mut ra = ChaChaRng::new_unseeded();
@@ -140,11 +141,10 @@ impl ChaChaRng {
     /// # Examples
     ///
     /// ```rust
-    /// use rand::{RngCore, ChaChaRng};
+    /// use rand::{ChaChaRng, RngCore, SeedableRng};
     ///
-    /// let mut rng1 = ChaChaRng::new_unseeded(); // Use `ChaChaRng::new()` or
-    ///                                           // `ChaChaRng::from_rng()`
-    ///                                           // outside of testing.
+    /// // Note: Use `NewRng` or `ChaChaRng::from_rng()` outside of testing.
+    /// let mut rng1 = ChaChaRng::from_seed([0; 32]);
     /// let mut rng2 = rng1.clone();
     ///
     /// // Skip to round 20. Because every round generates 16 `u32` values, this
@@ -168,11 +168,10 @@ impl ChaChaRng {
     /// # Examples
     ///
     /// ```rust
-    /// use rand::{RngCore, ChaChaRng};
+    /// use rand::{ChaChaRng, RngCore, SeedableRng};
     ///
-    /// let mut rng = ChaChaRng::new_unseeded(); // Use `ChaChaRng::new()` or
-    ///                                           // `ChaChaRng::from_rng()`
-    ///                                           // outside of testing.
+    /// // Note: Use `NewRng` or `ChaChaRng::from_rng()` outside of testing.
+    /// let mut rng = ChaChaRng::from_seed([0; 32]);
     /// rng.set_rounds(8);
     ///
     /// assert_eq!(rng.next_u32(), 0x2fef003e);

src/thread_rng.rs

@@ -129,6 +129,7 @@ impl CryptoRng for ThreadRng {}
 /// # Examples
 ///
 /// ```
+/// # #![allow(deprecated)]
 /// let x = rand::random::<u8>();
 /// println!("{}", x);
 ///
@@ -144,6 +145,7 @@ impl CryptoRng for ThreadRng {}
 /// following example can increase performance.
 ///
 /// ```
+/// # #![allow(deprecated)]
 /// use rand::Rng;
 ///
 /// let mut v = vec![1, 2, 3];