Doctests: Enable running doc tests for pedantic lints

clippy_lints/src/checked_conversions.rs

@@ -27,6 +27,8 @@ declare_clippy_lint! {
     /// Could be written:
     ///
     /// ```rust
+    /// # use std::convert::TryFrom;
+    /// # let foo = 1;
     /// # let _ =
     /// i32::try_from(foo).is_ok()
     /// # ;

clippy_lints/src/copy_iterator.rs

@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,ignore
     /// #[derive(Copy, Clone)]
     /// struct Countdown(u8);
     ///

clippy_lints/src/derive.rs

@@ -49,12 +49,12 @@ declare_clippy_lint! {
     /// **Known problems:** Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,ignore
     /// #[derive(Copy)]
     /// struct Foo;
     ///
     /// impl Clone for Foo {
-    ///     ..
+    ///     // ..
     /// }
     /// ```
     pub EXPL_IMPL_CLONE_ON_COPY,

clippy_lints/src/doc.rs

@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// /// Do something with the foo_bar parameter. See also
     /// /// that::other::module::foo.
     /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
-    /// fn doit(foo_bar) { .. }
+    /// fn doit(foo_bar: usize) {}
     /// ```
     pub DOC_MARKDOWN,
     pedantic,

clippy_lints/src/if_not_else.rs

@@ -17,6 +17,9 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// # let v: Vec<usize> = vec![];
+    /// # fn a() {}
+    /// # fn b() {}
     /// if !v.is_empty() {
     ///     a()
     /// } else {
@@ -27,6 +30,9 @@ declare_clippy_lint! {
     /// Could be written:
     ///
     /// ```rust
+    /// # let v: Vec<usize> = vec![];
+    /// # fn a() {}
+    /// # fn b() {}
     /// if v.is_empty() {
     ///     b()
     /// } else {

clippy_lints/src/infinite_iter.rs

@@ -34,7 +34,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// [0..].iter().zip(infinite_iter.take_while(|x| x > 5))
+    /// let infinite_iter = 0..;
+    /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
     /// ```
     pub MAYBE_INFINITE_ITER,
     pedantic,

clippy_lints/src/lib.rs

@@ -110,7 +110,7 @@ macro_rules! declare_clippy_lint {
     };
     { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
         declare_tool_lint! {
-            pub clippy::$name, Allow, $description, report_in_external_macro: true
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
         }
     };
     { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {

clippy_lints/src/loops.rs

@@ -91,16 +91,18 @@ declare_clippy_lint! {
     /// types.
     ///
     /// **Example:**
-    /// ```ignore
+    /// ```rust
     /// // with `y` a `Vec` or slice:
+    /// # let y = vec![1];
     /// for x in y.iter() {
-    ///     ..
+    ///     // ..
     /// }
     /// ```
     /// can be rewritten to
     /// ```rust
+    /// # let y = vec![1];
     /// for x in &y {
-    ///     ..
+    ///     // ..
     /// }
     /// ```
     pub EXPLICIT_ITER_LOOP,
@@ -117,16 +119,18 @@ declare_clippy_lint! {
     /// **Known problems:** None
     ///
     /// **Example:**
-    /// ```ignore
+    /// ```rust
+    /// # let y = vec![1];
     /// // with `y` a `Vec` or slice:
     /// for x in y.into_iter() {
-    ///     ..
+    ///     // ..
     /// }
     /// ```
     /// can be rewritten to
-    /// ```ignore
+    /// ```rust
+    /// # let y = vec![1];
     /// for x in y {
-    ///     ..
+    ///     // ..
     /// }
     /// ```
     pub EXPLICIT_INTO_ITER_LOOP,

clippy_lints/src/matches.rs

@@ -53,19 +53,25 @@ declare_clippy_lint! {
     /// Using `match`:
     ///
     /// ```rust
+    /// # fn bar(foo: &usize) {}
+    /// # let other_ref: usize = 1;
+    /// # let x: Option<&usize> = Some(&1);
     /// match x {
     ///     Some(ref foo) => bar(foo),
-    ///     _ => bar(other_ref),
+    ///     _ => bar(&other_ref),
     /// }
     /// ```
     ///
     /// Using `if let` with `else`:
     ///
     /// ```rust
+    /// # fn bar(foo: &usize) {}
+    /// # let other_ref: usize = 1;
+    /// # let x: Option<&usize> = Some(&1);
     /// if let Some(ref foo) = x {
     ///     bar(foo);
     /// } else {
-    ///     bar(other_ref);
+    ///     bar(&other_ref);
     /// }
     /// ```
     pub SINGLE_MATCH_ELSE,

clippy_lints/src/methods/mod.rs

@@ -179,7 +179,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// x.map(|a| a + 1).unwrap_or(0)
+    /// # let x = Some(1);
+    /// x.map(|a| a + 1).unwrap_or(0);
     /// ```
     pub OPTION_MAP_UNWRAP_OR,
     pedantic,
@@ -196,7 +197,9 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// x.map(|a| a + 1).unwrap_or_else(some_function)
+    /// # let x = Some(1);
+    /// # fn some_function() -> usize { 1 }
+    /// x.map(|a| a + 1).unwrap_or_else(some_function);
     /// ```
     pub OPTION_MAP_UNWRAP_OR_ELSE,
     pedantic,
@@ -213,7 +216,9 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// x.map(|a| a + 1).unwrap_or_else(some_function)
+    /// # let x: Result<usize, ()> = Ok(1);
+    /// # fn some_function(foo: ()) -> usize { 1 }
+    /// x.map(|a| a + 1).unwrap_or_else(some_function);
     /// ```
     pub RESULT_MAP_UNWRAP_OR_ELSE,
     pedantic,
@@ -265,7 +270,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// iter.map(|x| x.iter()).flatten()
+    /// let vec = vec![vec![1]];
+    /// vec.iter().map(|x| x.iter()).flatten();
     /// ```
     pub MAP_FLATTEN,
     pedantic,
@@ -284,7 +290,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// iter.filter(|x| x == 0).map(|x| x * 2)
+    /// let vec = vec![1];
+    /// vec.iter().filter(|x| **x == 0).map(|x| *x * 2);
     /// ```
     pub FILTER_MAP,
     pedantic,
@@ -324,7 +331,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    ///  (0..3).find(|x| x == 2).map(|x| x * 2);
+    ///  (0..3).find(|x| *x == 2).map(|x| x * 2);
     /// ```
     /// Can be written as
     /// ```rust

clippy_lints/src/mut_mut.rs

@@ -16,6 +16,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// # let mut y = 1;
     /// let x = &mut &mut y;
     /// ```
     pub MUT_MUT,

clippy_lints/src/needless_continue.rs

@@ -57,6 +57,9 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// # fn condition() -> bool { false }
+    /// # fn update_condition() {}
+    /// # let x = false;
     /// while condition() {
     ///     update_condition();
     ///     if x {
@@ -71,6 +74,9 @@ declare_clippy_lint! {
     /// Could be rewritten as
     ///
     /// ```rust
+    /// # fn condition() -> bool { false }
+    /// # fn update_condition() {}
+    /// # let x = false;
     /// while condition() {
     ///     update_condition();
     ///     if x {
@@ -83,22 +89,26 @@ declare_clippy_lint! {
     /// As another example, the following code
     ///
     /// ```rust
+    /// # fn waiting() -> bool { false }
     /// loop {
     ///     if waiting() {
     ///         continue;
     ///     } else {
     ///         // Do something useful
     ///     }
+    ///     # break;
     /// }
     /// ```
     /// Could be rewritten as
     ///
     /// ```rust
+    /// # fn waiting() -> bool { false }
     /// loop {
     ///     if waiting() {
     ///         continue;
     ///     }
     ///     // Do something useful
+    ///     # break;
     /// }
     /// ```
     pub NEEDLESS_CONTINUE,

clippy_lints/src/needless_pass_by_value.rs

@@ -40,6 +40,9 @@ declare_clippy_lint! {
     /// fn foo(v: Vec<i32>) {
     ///     assert_eq!(v.len(), 42);
     /// }
+    /// ```
+    ///
+    /// ```rust
     /// // should be
     /// fn foo(v: &[i32]) {
     ///     assert_eq!(v.len(), 42);

clippy_lints/src/replace_consts.rs

@@ -16,12 +16,14 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// # use core::sync::atomic::{ATOMIC_ISIZE_INIT, AtomicIsize};
     /// static FOO: AtomicIsize = ATOMIC_ISIZE_INIT;
     /// ```
     ///
     /// Could be written:
     ///
     /// ```rust
+    /// # use core::sync::atomic::AtomicIsize;
     /// static FOO: AtomicIsize = AtomicIsize::new(0);
     /// ```
     pub REPLACE_CONSTS,

clippy_lints/src/shadow.rs

@@ -67,6 +67,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// # let y = 1;
+    /// # let z = 2;
     /// let x = y;
     /// let x = z; // shadows the earlier binding
     /// ```

clippy_lints/src/types.rs

@@ -133,7 +133,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// let x = LinkedList::new();
+    /// # use std::collections::LinkedList;
+    /// let x: LinkedList<usize> = LinkedList::new();
     /// ```
     pub LINKEDLIST,
     pedantic,
@@ -660,8 +661,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// let x = u64::MAX;
-    /// x as f64
+    /// let x = std::u64::MAX;
+    /// x as f64;
     /// ```
     pub CAST_PRECISION_LOSS,
     pedantic,
@@ -682,7 +683,7 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// let y: i8 = -1;
-    /// y as u128 // will return 18446744073709551615
+    /// y as u128; // will return 18446744073709551615
     /// ```
     pub CAST_SIGN_LOSS,
     pedantic,
@@ -727,7 +728,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// u32::MAX as i32 // will yield a value of `-1`
+    /// std::u32::MAX as i32; // will yield a value of `-1`
     /// ```
     pub CAST_POSSIBLE_WRAP,
     pedantic,
@@ -1689,7 +1690,8 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// let x : u8 = ...; (x as u32) > 300
+    /// let x: u8 = 1;
+    /// (x as u32) > 300;
     /// ```
     pub INVALID_UPCAST_COMPARISONS,
     pedantic,