fix or ignore failing doc tests

clippy_lints/src/assertions_on_constants.rs

@@ -15,13 +15,13 @@ declare_clippy_lint! {
     /// **Known problems:** None
     ///
     /// **Example:**
-    /// ```rust
-    /// assert!(false)
+    /// ```no_run
+    /// assert!(false);
     /// // or
-    /// assert!(true)
+    /// assert!(true);
     /// // or
     /// const B: bool = false;
-    /// assert!(B)
+    /// assert!(B);
     /// ```
     pub ASSERTIONS_ON_CONSTANTS,
     style,

clippy_lints/src/assign_ops.rs

@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// implementations that differ from the regular `Op` impl.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// let mut a = 5;
     /// ...
     /// a = a + b;
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// written as `a = a op a op b` as it's less confusing.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// let mut a = 5;
     /// ...
     /// a += a + b;

clippy_lints/src/attrs.rs

@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// done the measurement.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// #[inline(always)]
     /// fn not_quite_hot_code(..) { ... }
     /// ```
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// // Bad
     /// #[deny(dead_code)]
     /// extern crate foo;
@@ -88,7 +88,7 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// #[deprecated(since = "forever")]
-    /// fn something_else(..) { ... }
+    /// fn something_else() { /* ... */ }
     /// ```
     pub DEPRECATED_SEMVER,
     correctness,

clippy_lints/src/bit_mask.rs

@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// if (x & 1 == 2) { … }
     /// ```
     pub BAD_BIT_MASK,
@@ -65,7 +65,7 @@ declare_clippy_lint! {
     /// uncommon).
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// if (x | 1 > 3) { … }
     /// ```
     pub INEFFECTIVE_BIT_MASK,
@@ -83,7 +83,7 @@ declare_clippy_lint! {
     /// **Known problems:** llvm generates better code for `x & 15 == 0` on x86
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// x & 0x1111 == 0
     /// ```
     pub VERBOSE_BIT_MASK,

clippy_lints/src/block_in_if_condition.rs

@@ -16,7 +16,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// if { true } ..
+    /// if { true } { /* ... */ }
     /// ```
     pub BLOCK_IN_IF_CONDITION_EXPR,
     style,
@@ -32,10 +32,10 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
-    /// if { let x = somefunc(); x } ..
+    /// ```ignore
+    /// if { let x = somefunc(); x } {}
     /// // or
-    /// if somefunc(|x| { x == 47 }) ..
+    /// if somefunc(|x| { x == 47 }) {}
     /// ```
     pub BLOCK_IN_IF_CONDITION_STMT,
     style,

clippy_lints/src/booleans.rs

@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// `&&`. Ignores `|`, `&` and `^`.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// if a && true  // should be: if a
     /// if !(a == b)  // should be: if a != b
     /// ```
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// **Known problems:** Ignores short circuiting behavior.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// if a && b || a { ... }
     /// ```
     /// The `b` is unnecessary, the expression is equivalent to `if a`.

clippy_lints/src/const_static_lifetime.rs

@@ -13,12 +13,12 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// const FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =
     /// &[...]
     /// ```
     /// This code can be rewritten as
-    /// ```rust
+    /// ```ignore
     ///  const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
     /// ```
     pub CONST_STATIC_LIFETIME,

clippy_lints/src/copies.rs

@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// **Known problems:** Hopefully none.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// if a == b {
     ///     …
     /// } else if a == b {
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// Note that this lint ignores all conditions with a function call as it could
     /// have side effects:
     ///
-    /// ```rust
+    /// ```ignore
     /// if foo() {
     ///     …
     /// } else if foo() { // not linted
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// **Known problems:** Hopefully none.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// let foo = if … {
     ///     42
     /// } else {

clippy_lints/src/derive.rs

@@ -16,14 +16,14 @@ declare_clippy_lint! {
     /// default-generated `Hash` implementation with an explicitly defined
     /// `PartialEq`. In particular, the following must hold for any type:
     ///
-    /// ```rust
+    /// ```text
     /// k1 == k2 ⇒ hash(k1) == hash(k2)
     /// ```
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// #[derive(Hash)]
     /// struct Foo;
     ///

clippy_lints/src/drop_forget_ref.rs

@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// let mut lock_guard = mutex.lock();
     /// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex
     /// // still locked

clippy_lints/src/enum_variants.rs

@@ -88,7 +88,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// // lib.rs
     /// mod foo;
     /// // foo.rs

clippy_lints/src/eq_op.rs

@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// calls. We may introduce a whitelist of known pure functions in the future.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// x + 1 == x + 1
     /// ```
     pub EQ_OP,
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// **Known problems:** None
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// &x == y
     /// ```
     pub OP_REF,

clippy_lints/src/erasing_op.rs

@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// 0 / x;
     /// 0 * x;
     /// x & 0

clippy_lints/src/eta_reduction.rs

@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// details.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// xs.map(|x| foo(x))
     /// ```
     /// where `foo(_)` is a plain function that takes the exact argument type of

clippy_lints/src/indexing_slicing.rs

@@ -19,7 +19,8 @@ declare_clippy_lint! {
     /// **Known problems:** Hopefully none.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```no_run
+    /// # #![allow(const_err)]
     /// let x = [1, 2, 3, 4];
     ///
     /// // Bad

clippy_lints/src/infinite_iter.rs

@@ -12,8 +12,10 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
-    /// repeat(1_u8).iter().collect::<Vec<_>>()
+    /// ```no_run
+    /// use std::iter;
+    ///
+    /// iter::repeat(1_u8).collect::<Vec<_>>();
     /// ```
     pub INFINITE_ITER,
     correctness,

clippy_lints/src/invalid_ref.rs

@@ -13,8 +13,8 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
-    /// let bad_ref: &usize = std::mem::zeroed();
+    /// ```no_run
+    /// let bad_ref: &usize = unsafe { std::mem::zeroed() };
     /// ```
     pub INVALID_REF,
     correctness,

clippy_lints/src/len_zero.rs

@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// if x.len() == 0 {
     ///     ..
     /// }
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// instead use
-    /// ```rust
+    /// ```ignore
     /// if x.is_empty() {
     ///     ..
     /// }
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```ignore
     /// impl X {
     ///     pub fn len(&self) -> usize {
     ///         ..

clippy_lints/src/literal_representation.rs

@@ -20,7 +20,7 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// 61864918973511
+    /// let x: u64 = 61864918973511;
     /// ```
     pub UNREADABLE_LITERAL,
     style,
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// 2_32
+    /// 2_32;
     /// ```
     pub MISTYPED_LITERAL_SUFFIXES,
     correctness,
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// 618_64_9189_73_511
+    /// let x: u64 = 618_64_9189_73_511;
     /// ```
     pub INCONSISTENT_DIGIT_GROUPING,
     style,
@@ -78,7 +78,7 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// 6186491_8973511
+    /// let x: u64 = 6186491_8973511;
     /// ```
     pub LARGE_DIGIT_GROUPS,
     pedantic,