rust-lang-ci
diff --git a/‎tests/ui/absurd-extreme-comparisons.stderr
Lines changed: 17 additions & 17 deletions b/‎tests/ui/absurd-extreme-comparisons.stderr
Lines changed: 17 additions & 17 deletions
diff --git a/‎tests/ui/assign_ops2.stderr
Lines changed: 9 additions & 9 deletions b/‎tests/ui/assign_ops2.stderr
Lines changed: 9 additions & 9 deletions
diff --git a/‎tests/ui/block_in_if_condition.stderr
Lines changed: 3 additions & 3 deletions b/‎tests/ui/block_in_if_condition.stderr
Lines changed: 3 additions & 3 deletions
diff --git a/‎tests/ui/cast.stderr
Lines changed: 16 additions & 16 deletions b/‎tests/ui/cast.stderr
Lines changed: 16 additions & 16 deletions
@@ -5,135 +5,135 @@ LL |     u <= 0;
    |     ^^^^^^
    |
    = note: `-D clippy::absurd-extreme-comparisons` implied by `-D warnings`
-   = help: because 0 is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == 0 instead
+   = help: because `0` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == 0` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:15:5
    |
 LL |     u <= Z;
    |     ^^^^^^
    |
-   = help: because Z is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == Z instead
+   = help: because `Z` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == Z` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:16:5
    |
 LL |     u < Z;
    |     ^^^^^
    |
-   = help: because Z is the minimum value for this type, this comparison is always false
+   = help: because `Z` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:17:5
    |
 LL |     Z >= u;
    |     ^^^^^^
    |
-   = help: because Z is the minimum value for this type, the case where the two sides are not equal never occurs, consider using Z == u instead
+   = help: because `Z` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `Z == u` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:18:5
    |
 LL |     Z > u;
    |     ^^^^^
    |
-   = help: because Z is the minimum value for this type, this comparison is always false
+   = help: because `Z` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:19:5
    |
 LL |     u > std::u32::MAX;
    |     ^^^^^^^^^^^^^^^^^
    |
-   = help: because std::u32::MAX is the maximum value for this type, this comparison is always false
+   = help: because `std::u32::MAX` is the maximum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:20:5
    |
 LL |     u >= std::u32::MAX;
    |     ^^^^^^^^^^^^^^^^^^
    |
-   = help: because std::u32::MAX is the maximum value for this type, the case where the two sides are not equal never occurs, consider using u == std::u32::MAX instead
+   = help: because `std::u32::MAX` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `u == std::u32::MAX` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:21:5
    |
 LL |     std::u32::MAX < u;
    |     ^^^^^^^^^^^^^^^^^
    |
-   = help: because std::u32::MAX is the maximum value for this type, this comparison is always false
+   = help: because `std::u32::MAX` is the maximum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:22:5
    |
 LL |     std::u32::MAX <= u;
    |     ^^^^^^^^^^^^^^^^^^
    |
-   = help: because std::u32::MAX is the maximum value for this type, the case where the two sides are not equal never occurs, consider using std::u32::MAX == u instead
+   = help: because `std::u32::MAX` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `std::u32::MAX == u` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:23:5
    |
 LL |     1-1 > u;
    |     ^^^^^^^
    |
-   = help: because 1-1 is the minimum value for this type, this comparison is always false
+   = help: because `1-1` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:24:5
    |
 LL |     u >= !0;
    |     ^^^^^^^
    |
-   = help: because !0 is the maximum value for this type, the case where the two sides are not equal never occurs, consider using u == !0 instead
+   = help: because `!0` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `u == !0` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:25:5
    |
 LL |     u <= 12 - 2*6;
    |     ^^^^^^^^^^^^^
    |
-   = help: because 12 - 2*6 is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == 12 - 2*6 instead
+   = help: because `12 - 2*6` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == 12 - 2*6` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:27:5
    |
 LL |     i < -127 - 1;
    |     ^^^^^^^^^^^^
    |
-   = help: because -127 - 1 is the minimum value for this type, this comparison is always false
+   = help: because `-127 - 1` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:28:5
    |
 LL |     std::i8::MAX >= i;
    |     ^^^^^^^^^^^^^^^^^
    |
-   = help: because std::i8::MAX is the maximum value for this type, this comparison is always true
+   = help: because `std::i8::MAX` is the maximum value for this type, this comparison is always true
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:29:5
    |
 LL |     3-7 < std::i32::MIN;
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: because std::i32::MIN is the minimum value for this type, this comparison is always false
+   = help: because `std::i32::MIN` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:31:5
    |
 LL |     b >= true;
    |     ^^^^^^^^^
    |
-   = help: because true is the maximum value for this type, the case where the two sides are not equal never occurs, consider using b == true instead
+   = help: because `true` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `b == true` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
   --> $DIR/absurd-extreme-comparisons.rs:32:5
    |
 LL |     false > b;
    |     ^^^^^^^^^
    |
-   = help: because false is the minimum value for this type, this comparison is always false
+   = help: because `false` is the minimum value for this type, this comparison is always false
 
 error: <-comparison of unit values detected. This will always be false
   --> $DIR/absurd-extreme-comparisons.rs:35:5
 
@@ -5,7 +5,7 @@ LL |     a += a + 1;
    |     ^^^^^^^^^^
    |
    = note: `-D clippy::misrefactored-assign-op` implied by `-D warnings`
-help: Did you mean a = a + 1 or a = a + a + 1? Consider replacing it with
+help: Did you mean `a = a + 1` or `a = a + a + 1`? Consider replacing it with
    |
 LL |     a += 1;
    |     ^^^^^^
@@ -20,7 +20,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a += 1 + a;
    |     ^^^^^^^^^^
    |
-help: Did you mean a = a + 1 or a = a + 1 + a? Consider replacing it with
+help: Did you mean `a = a + 1` or `a = a + 1 + a`? Consider replacing it with
    |
 LL |     a += 1;
    |     ^^^^^^
@@ -35,7 +35,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a -= a - 1;
    |     ^^^^^^^^^^
    |
-help: Did you mean a = a - 1 or a = a - (a - 1)? Consider replacing it with
+help: Did you mean `a = a - 1` or `a = a - (a - 1)`? Consider replacing it with
    |
 LL |     a -= 1;
    |     ^^^^^^
@@ -50,7 +50,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a *= a * 99;
    |     ^^^^^^^^^^^
    |
-help: Did you mean a = a * 99 or a = a * a * 99? Consider replacing it with
+help: Did you mean `a = a * 99` or `a = a * a * 99`? Consider replacing it with
    |
 LL |     a *= 99;
    |     ^^^^^^^
@@ -65,7 +65,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a *= 42 * a;
    |     ^^^^^^^^^^^
    |
-help: Did you mean a = a * 42 or a = a * 42 * a? Consider replacing it with
+help: Did you mean `a = a * 42` or `a = a * 42 * a`? Consider replacing it with
    |
 LL |     a *= 42;
    |     ^^^^^^^
@@ -80,7 +80,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a /= a / 2;
    |     ^^^^^^^^^^
    |
-help: Did you mean a = a / 2 or a = a / (a / 2)? Consider replacing it with
+help: Did you mean `a = a / 2` or `a = a / (a / 2)`? Consider replacing it with
    |
 LL |     a /= 2;
    |     ^^^^^^
@@ -95,7 +95,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a %= a % 5;
    |     ^^^^^^^^^^
    |
-help: Did you mean a = a % 5 or a = a % (a % 5)? Consider replacing it with
+help: Did you mean `a = a % 5` or `a = a % (a % 5)`? Consider replacing it with
    |
 LL |     a %= 5;
    |     ^^^^^^
@@ -110,7 +110,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a &= a & 1;
    |     ^^^^^^^^^^
    |
-help: Did you mean a = a & 1 or a = a & a & 1? Consider replacing it with
+help: Did you mean `a = a & 1` or `a = a & a & 1`? Consider replacing it with
    |
 LL |     a &= 1;
    |     ^^^^^^
@@ -125,7 +125,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a *= a * a;
    |     ^^^^^^^^^^
    |
-help: Did you mean a = a * a or a = a * a * a? Consider replacing it with
+help: Did you mean `a = a * a` or `a = a * a * a`? Consider replacing it with
    |
 LL |     a *= a;
    |     ^^^^^^
 
@@ -1,4 +1,4 @@
-error: in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
   --> $DIR/block_in_if_condition.rs:26:8
    |
 LL |       if {
@@ -30,7 +30,7 @@ LL |     if { true } {
                6
            } ... 
 
-error: in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
   --> $DIR/block_in_if_condition.rs:58:17
    |
 LL |               |x| {
@@ -40,7 +40,7 @@ LL | |                 x == target
 LL | |             },
    | |_____________^
 
-error: in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
   --> $DIR/block_in_if_condition.rs:67:13
    |
 LL |           |x| {
 
@@ -36,103 +36,103 @@ error: casting u64 to f64 causes a loss of precision (u64 is 64 bits wide, but f
 LL |     x3 as f64;
    |     ^^^^^^^^^
 
-error: casting f32 to i32 may truncate the value
+error: casting `f32` to `i32` may truncate the value
   --> $DIR/cast.rs:21:5
    |
 LL |     1f32 as i32;
    |     ^^^^^^^^^^^
    |
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
 
-error: casting f32 to u32 may truncate the value
+error: casting `f32` to `u32` may truncate the value
   --> $DIR/cast.rs:22:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
 
-error: casting f32 to u32 may lose the sign of the value
+error: casting `f32` to `u32` may lose the sign of the value
   --> $DIR/cast.rs:22:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
    |
    = note: `-D clippy::cast-sign-loss` implied by `-D warnings`
 
-error: casting f64 to f32 may truncate the value
+error: casting `f64` to `f32` may truncate the value
   --> $DIR/cast.rs:23:5
    |
 LL |     1f64 as f32;
    |     ^^^^^^^^^^^
 
-error: casting i32 to i8 may truncate the value
+error: casting `i32` to `i8` may truncate the value
   --> $DIR/cast.rs:24:5
    |
 LL |     1i32 as i8;
    |     ^^^^^^^^^^
 
-error: casting i32 to u8 may truncate the value
+error: casting `i32` to `u8` may truncate the value
   --> $DIR/cast.rs:25:5
    |
 LL |     1i32 as u8;
    |     ^^^^^^^^^^
 
-error: casting f64 to isize may truncate the value
+error: casting `f64` to `isize` may truncate the value
   --> $DIR/cast.rs:26:5
    |
 LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
 
-error: casting f64 to usize may truncate the value
+error: casting `f64` to `usize` may truncate the value
   --> $DIR/cast.rs:27:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
-error: casting f64 to usize may lose the sign of the value
+error: casting `f64` to `usize` may lose the sign of the value
   --> $DIR/cast.rs:27:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
-error: casting u8 to i8 may wrap around the value
+error: casting `u8` to `i8` may wrap around the value
   --> $DIR/cast.rs:29:5
    |
 LL |     1u8 as i8;
    |     ^^^^^^^^^
    |
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
 
-error: casting u16 to i16 may wrap around the value
+error: casting `u16` to `i16` may wrap around the value
   --> $DIR/cast.rs:30:5
    |
 LL |     1u16 as i16;
    |     ^^^^^^^^^^^
 
-error: casting u32 to i32 may wrap around the value
+error: casting `u32` to `i32` may wrap around the value
   --> $DIR/cast.rs:31:5
    |
 LL |     1u32 as i32;
    |     ^^^^^^^^^^^
 
-error: casting u64 to i64 may wrap around the value
+error: casting `u64` to `i64` may wrap around the value
   --> $DIR/cast.rs:32:5
    |
 LL |     1u64 as i64;
    |     ^^^^^^^^^^^
 
-error: casting usize to isize may wrap around the value
+error: casting `usize` to `isize` may wrap around the value
   --> $DIR/cast.rs:33:5
    |
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
-error: casting i32 to u32 may lose the sign of the value
+error: casting `i32` to `u32` may lose the sign of the value
   --> $DIR/cast.rs:36:5
    |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
-error: casting isize to usize may lose the sign of the value
+error: casting `isize` to `usize` may lose the sign of the value
   --> $DIR/cast.rs:38:5
    |
 LL |     -1isize as usize;
Original file line number	Diff line number	Diff line change
`@@ -5,135 +5,135 @@ LL \| u <= 0;`
`5`	`5`	`\| ^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::absurd-extreme-comparisons` implied by `-D warnings`
`8`		`- = help: because 0 is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == 0 instead`
	`8`	+ = help: because `0` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == 0` instead
`9`	`9`
`10`	`10`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`11`	`11`	`--> $DIR/absurd-extreme-comparisons.rs:15:5`
`12`	`12`	`\|`
`13`	`13`	`LL \| u <= Z;`
`14`	`14`	`\| ^^^^^^`
`15`	`15`	`\|`
`16`		`- = help: because Z is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == Z instead`
	`16`	+ = help: because `Z` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == Z` instead
`17`	`17`
`18`	`18`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`19`	`19`	`--> $DIR/absurd-extreme-comparisons.rs:16:5`
`20`	`20`	`\|`
`21`	`21`	`LL \| u < Z;`
`22`	`22`	`\| ^^^^^`
`23`	`23`	`\|`
`24`		`- = help: because Z is the minimum value for this type, this comparison is always false`
	`24`	+ = help: because `Z` is the minimum value for this type, this comparison is always false
`25`	`25`
`26`	`26`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`27`	`27`	`--> $DIR/absurd-extreme-comparisons.rs:17:5`
`28`	`28`	`\|`
`29`	`29`	`LL \| Z >= u;`
`30`	`30`	`\| ^^^^^^`
`31`	`31`	`\|`
`32`		`- = help: because Z is the minimum value for this type, the case where the two sides are not equal never occurs, consider using Z == u instead`
	`32`	+ = help: because `Z` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `Z == u` instead
`33`	`33`
`34`	`34`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`35`	`35`	`--> $DIR/absurd-extreme-comparisons.rs:18:5`
`36`	`36`	`\|`
`37`	`37`	`LL \| Z > u;`
`38`	`38`	`\| ^^^^^`
`39`	`39`	`\|`
`40`		`- = help: because Z is the minimum value for this type, this comparison is always false`
	`40`	+ = help: because `Z` is the minimum value for this type, this comparison is always false
`41`	`41`
`42`	`42`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`43`	`43`	`--> $DIR/absurd-extreme-comparisons.rs:19:5`
`44`	`44`	`\|`
`45`	`45`	`LL \| u > std::u32::MAX;`
`46`	`46`	`\| ^^^^^^^^^^^^^^^^^`
`47`	`47`	`\|`
`48`		`- = help: because std::u32::MAX is the maximum value for this type, this comparison is always false`
	`48`	+ = help: because `std::u32::MAX` is the maximum value for this type, this comparison is always false
`49`	`49`
`50`	`50`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`51`	`51`	`--> $DIR/absurd-extreme-comparisons.rs:20:5`
`52`	`52`	`\|`
`53`	`53`	`LL \| u >= std::u32::MAX;`
`54`	`54`	`\| ^^^^^^^^^^^^^^^^^^`
`55`	`55`	`\|`
`56`		`- = help: because std::u32::MAX is the maximum value for this type, the case where the two sides are not equal never occurs, consider using u == std::u32::MAX instead`
	`56`	+ = help: because `std::u32::MAX` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `u == std::u32::MAX` instead
`57`	`57`
`58`	`58`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`59`	`59`	`--> $DIR/absurd-extreme-comparisons.rs:21:5`
`60`	`60`	`\|`
`61`	`61`	`LL \| std::u32::MAX < u;`
`62`	`62`	`\| ^^^^^^^^^^^^^^^^^`
`63`	`63`	`\|`
`64`		`- = help: because std::u32::MAX is the maximum value for this type, this comparison is always false`
	`64`	+ = help: because `std::u32::MAX` is the maximum value for this type, this comparison is always false
`65`	`65`
`66`	`66`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`67`	`67`	`--> $DIR/absurd-extreme-comparisons.rs:22:5`
`68`	`68`	`\|`
`69`	`69`	`LL \| std::u32::MAX <= u;`
`70`	`70`	`\| ^^^^^^^^^^^^^^^^^^`
`71`	`71`	`\|`
`72`		`- = help: because std::u32::MAX is the maximum value for this type, the case where the two sides are not equal never occurs, consider using std::u32::MAX == u instead`
	`72`	+ = help: because `std::u32::MAX` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `std::u32::MAX == u` instead
`73`	`73`
`74`	`74`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`75`	`75`	`--> $DIR/absurd-extreme-comparisons.rs:23:5`
`76`	`76`	`\|`
`77`	`77`	`LL \| 1-1 > u;`
`78`	`78`	`\| ^^^^^^^`
`79`	`79`	`\|`
`80`		`- = help: because 1-1 is the minimum value for this type, this comparison is always false`
	`80`	+ = help: because `1-1` is the minimum value for this type, this comparison is always false
`81`	`81`
`82`	`82`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`83`	`83`	`--> $DIR/absurd-extreme-comparisons.rs:24:5`
`84`	`84`	`\|`
`85`	`85`	`LL \| u >= !0;`
`86`	`86`	`\| ^^^^^^^`
`87`	`87`	`\|`
`88`		`- = help: because !0 is the maximum value for this type, the case where the two sides are not equal never occurs, consider using u == !0 instead`
	`88`	+ = help: because `!0` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `u == !0` instead
`89`	`89`
`90`	`90`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`91`	`91`	`--> $DIR/absurd-extreme-comparisons.rs:25:5`
`92`	`92`	`\|`
`93`	`93`	`LL \| u <= 12 - 2*6;`
`94`	`94`	`\| ^^^^^^^^^^^^^`
`95`	`95`	`\|`
`96`		`- = help: because 12 - 26 is the minimum value for this type, the case where the two sides are not equal never occurs, consider using u == 12 - 26 instead`
	`96`	+ = help: because `12 - 26` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == 12 - 26` instead
`97`	`97`
`98`	`98`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`99`	`99`	`--> $DIR/absurd-extreme-comparisons.rs:27:5`
`100`	`100`	`\|`
`101`	`101`	`LL \| i < -127 - 1;`
`102`	`102`	`\| ^^^^^^^^^^^^`
`103`	`103`	`\|`
`104`		`- = help: because -127 - 1 is the minimum value for this type, this comparison is always false`
	`104`	+ = help: because `-127 - 1` is the minimum value for this type, this comparison is always false
`105`	`105`
`106`	`106`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`107`	`107`	`--> $DIR/absurd-extreme-comparisons.rs:28:5`
`108`	`108`	`\|`
`109`	`109`	`LL \| std::i8::MAX >= i;`
`110`	`110`	`\| ^^^^^^^^^^^^^^^^^`
`111`	`111`	`\|`
`112`		`- = help: because std::i8::MAX is the maximum value for this type, this comparison is always true`
	`112`	+ = help: because `std::i8::MAX` is the maximum value for this type, this comparison is always true
`113`	`113`
`114`	`114`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`115`	`115`	`--> $DIR/absurd-extreme-comparisons.rs:29:5`
`116`	`116`	`\|`
`117`	`117`	`LL \| 3-7 < std::i32::MIN;`
`118`	`118`	`\| ^^^^^^^^^^^^^^^^^^^`
`119`	`119`	`\|`
`120`		`- = help: because std::i32::MIN is the minimum value for this type, this comparison is always false`
	`120`	+ = help: because `std::i32::MIN` is the minimum value for this type, this comparison is always false
`121`	`121`
`122`	`122`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`123`	`123`	`--> $DIR/absurd-extreme-comparisons.rs:31:5`
`124`	`124`	`\|`
`125`	`125`	`LL \| b >= true;`
`126`	`126`	`\| ^^^^^^^^^`
`127`	`127`	`\|`
`128`		`- = help: because true is the maximum value for this type, the case where the two sides are not equal never occurs, consider using b == true instead`
	`128`	+ = help: because `true` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `b == true` instead
`129`	`129`
`130`	`130`	`error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false`
`131`	`131`	`--> $DIR/absurd-extreme-comparisons.rs:32:5`
`132`	`132`	`\|`
`133`	`133`	`LL \| false > b;`
`134`	`134`	`\| ^^^^^^^^^`
`135`	`135`	`\|`
`136`		`- = help: because false is the minimum value for this type, this comparison is always false`
	`136`	+ = help: because `false` is the minimum value for this type, this comparison is always false
`137`	`137`
`138`	`138`	`error: <-comparison of unit values detected. This will always be false`
`139`	`139`	`--> $DIR/absurd-extreme-comparisons.rs:35:5`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ LL \| a += a + 1;`
`5`	`5`	`\| ^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::misrefactored-assign-op` implied by `-D warnings`
`8`		`-help: Did you mean a = a + 1 or a = a + a + 1? Consider replacing it with`
	`8`	+help: Did you mean `a = a + 1` or `a = a + a + 1`? Consider replacing it with
`9`	`9`	`\|`
`10`	`10`	`LL \| a += 1;`
`11`	`11`	`\| ^^^^^^`
`@@ -20,7 +20,7 @@ error: variable appears on both sides of an assignment operation`
`20`	`20`	`LL \| a += 1 + a;`
`21`	`21`	`\| ^^^^^^^^^^`
`22`	`22`	`\|`
`23`		`-help: Did you mean a = a + 1 or a = a + 1 + a? Consider replacing it with`
	`23`	+help: Did you mean `a = a + 1` or `a = a + 1 + a`? Consider replacing it with
`24`	`24`	`\|`
`25`	`25`	`LL \| a += 1;`
`26`	`26`	`\| ^^^^^^`
`@@ -35,7 +35,7 @@ error: variable appears on both sides of an assignment operation`
`35`	`35`	`LL \| a -= a - 1;`
`36`	`36`	`\| ^^^^^^^^^^`
`37`	`37`	`\|`
`38`		`-help: Did you mean a = a - 1 or a = a - (a - 1)? Consider replacing it with`
	`38`	+help: Did you mean `a = a - 1` or `a = a - (a - 1)`? Consider replacing it with
`39`	`39`	`\|`
`40`	`40`	`LL \| a -= 1;`
`41`	`41`	`\| ^^^^^^`
`@@ -50,7 +50,7 @@ error: variable appears on both sides of an assignment operation`
`50`	`50`	`LL \| a = a 99;`
`51`	`51`	`\| ^^^^^^^^^^^`
`52`	`52`	`\|`
`53`		`-help: Did you mean a = a * 99 or a = a * a * 99? Consider replacing it with`
	`53`	+help: Did you mean `a = a * 99` or `a = a * a * 99`? Consider replacing it with
`54`	`54`	`\|`
`55`	`55`	`LL \| a *= 99;`
`56`	`56`	`\| ^^^^^^^`
`@@ -65,7 +65,7 @@ error: variable appears on both sides of an assignment operation`
`65`	`65`	`LL \| a = 42 a;`
`66`	`66`	`\| ^^^^^^^^^^^`
`67`	`67`	`\|`
`68`		`-help: Did you mean a = a * 42 or a = a * 42 * a? Consider replacing it with`
	`68`	+help: Did you mean `a = a * 42` or `a = a * 42 * a`? Consider replacing it with
`69`	`69`	`\|`
`70`	`70`	`LL \| a *= 42;`
`71`	`71`	`\| ^^^^^^^`
`@@ -80,7 +80,7 @@ error: variable appears on both sides of an assignment operation`
`80`	`80`	`LL \| a /= a / 2;`
`81`	`81`	`\| ^^^^^^^^^^`
`82`	`82`	`\|`
`83`		`-help: Did you mean a = a / 2 or a = a / (a / 2)? Consider replacing it with`
	`83`	+help: Did you mean `a = a / 2` or `a = a / (a / 2)`? Consider replacing it with
`84`	`84`	`\|`
`85`	`85`	`LL \| a /= 2;`
`86`	`86`	`\| ^^^^^^`
`@@ -95,7 +95,7 @@ error: variable appears on both sides of an assignment operation`
`95`	`95`	`LL \| a %= a % 5;`
`96`	`96`	`\| ^^^^^^^^^^`
`97`	`97`	`\|`
`98`		`-help: Did you mean a = a % 5 or a = a % (a % 5)? Consider replacing it with`
	`98`	+help: Did you mean `a = a % 5` or `a = a % (a % 5)`? Consider replacing it with
`99`	`99`	`\|`
`100`	`100`	`LL \| a %= 5;`
`101`	`101`	`\| ^^^^^^`
`@@ -110,7 +110,7 @@ error: variable appears on both sides of an assignment operation`
`110`	`110`	`LL \| a &= a & 1;`
`111`	`111`	`\| ^^^^^^^^^^`
`112`	`112`	`\|`
`113`		`-help: Did you mean a = a & 1 or a = a & a & 1? Consider replacing it with`
	`113`	+help: Did you mean `a = a & 1` or `a = a & a & 1`? Consider replacing it with
`114`	`114`	`\|`
`115`	`115`	`LL \| a &= 1;`
`116`	`116`	`\| ^^^^^^`
`@@ -125,7 +125,7 @@ error: variable appears on both sides of an assignment operation`
`125`	`125`	`LL \| a = a a;`
`126`	`126`	`\| ^^^^^^^^^^`
`127`	`127`	`\|`
`128`		`-help: Did you mean a = a * a or a = a * a * a? Consider replacing it with`
	`128`	+help: Did you mean `a = a * a` or `a = a * a * a`? Consider replacing it with
`129`	`129`	`\|`
`130`	`130`	`LL \| a *= a;`
`131`	`131`	`\| ^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-error: in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'`
	`1`	+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
`2`	`2`	`--> $DIR/block_in_if_condition.rs:26:8`
`3`	`3`	`\|`
`4`	`4`	`LL \| if {`
`@@ -30,7 +30,7 @@ LL \| if { true } {`
`30`	`30`	`6`
`31`	`31`	`} ...`
`32`	`32`
`33`		`-error: in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'`
	`33`	+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
`34`	`34`	`--> $DIR/block_in_if_condition.rs:58:17`
`35`	`35`	`\|`
`36`	`36`	`LL \| \|x\| {`
`@@ -40,7 +40,7 @@ LL \| \| x == target`
`40`	`40`	`LL \| \| },`
`41`	`41`	`\| \|_____________^`
`42`	`42`
`43`		`-error: in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'`
	`43`	+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
`44`	`44`	`--> $DIR/block_in_if_condition.rs:67:13`
`45`	`45`	`\|`
`46`	`46`	`LL \| \|x\| {`