Move if_then_panic to pedantic

camsteffen · camsteffen · commit d8fcfd7d64f1 · 2021-10-28T09:38:01.000-05:00
diff --git a/clippy_lints/src/if_then_panic.rs b/clippy_lints/src/if_then_panic.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
     /// ```
     pub IF_THEN_PANIC,
-    style,
+    pedantic,
     "`panic!` and only a `panic!` in `if`-then statement"
 }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
@@ -76,7 +76,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
     LintId::of(identity_op::IDENTITY_OP),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
-    LintId::of(if_then_panic::IF_THEN_PANIC),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
     LintId::of(infinite_iter::INFINITE_ITER),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
@@ -34,6 +34,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(functions::MUST_USE_CANDIDATE),
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
+    LintId::of(if_then_panic::IF_THEN_PANIC),
     LintId::of(implicit_hasher::IMPLICIT_HASHER),
     LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
     LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
@@ -27,7 +27,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(functions::DOUBLE_MUST_USE),
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::RESULT_UNIT_ERR),
-    LintId::of(if_then_panic::IF_THEN_PANIC),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
     LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
diff --git a/tests/ui/fallible_impl_from.rs b/tests/ui/fallible_impl_from.rs
@@ -1,5 +1,4 @@
 #![deny(clippy::fallible_impl_from)]
-#![allow(clippy::if_then_panic)]
 
 // docs example
 struct Foo(i32);
diff --git a/tests/ui/fallible_impl_from.stderr b/tests/ui/fallible_impl_from.stderr
@@ -1,5 +1,5 @@
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:6:1
+  --> $DIR/fallible_impl_from.rs:5:1
    |
 LL | / impl From<String> for Foo {
 LL | |     fn from(s: String) -> Self {
@@ -15,13 +15,13 @@ LL | #![deny(clippy::fallible_impl_from)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:8:13
+  --> $DIR/fallible_impl_from.rs:7:13
    |
 LL |         Foo(s.parse().unwrap())
    |             ^^^^^^^^^^^^^^^^^^
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:27:1
+  --> $DIR/fallible_impl_from.rs:26:1
    |
 LL | / impl From<usize> for Invalid {
 LL | |     fn from(i: usize) -> Invalid {
@@ -34,14 +34,14 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:30:13
+  --> $DIR/fallible_impl_from.rs:29:13
    |
 LL |             panic!();
    |             ^^^^^^^^
    = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:36:1
+  --> $DIR/fallible_impl_from.rs:35:1
    |
 LL | / impl From<Option<String>> for Invalid {
 LL | |     fn from(s: Option<String>) -> Invalid {
@@ -54,7 +54,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:38:17
+  --> $DIR/fallible_impl_from.rs:37:17
    |
 LL |         let s = s.unwrap();
    |                 ^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |             panic!("{:?}", s);
    = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:54:1
+  --> $DIR/fallible_impl_from.rs:53:1
    |
 LL | / impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {
 LL | |     fn from(s: &'a mut <Box<u32> as ProjStrTrait>::ProjString) -> Invalid {
@@ -81,7 +81,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:56:12
+  --> $DIR/fallible_impl_from.rs:55:12
    |
 LL |         if s.parse::<u32>().ok().unwrap() != 42 {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
@@ -1,9 +1,4 @@
-#![allow(
-    unused,
-    clippy::many_single_char_names,
-    clippy::redundant_clone,
-    clippy::if_then_panic
-)]
+#![allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
 #![warn(clippy::ptr_arg)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
@@ -1,31 +1,31 @@
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:12:14
+  --> $DIR/ptr_arg.rs:7:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
    |              ^^^^^^^^^ help: change this to: `&[i64]`
    |
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:21:14
+  --> $DIR/ptr_arg.rs:16:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:30:15
+  --> $DIR/ptr_arg.rs:25:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:43:18
+  --> $DIR/ptr_arg.rs:38:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:56:14
+  --> $DIR/ptr_arg.rs:51:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -44,7 +44,7 @@ LL |     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:65:18
+  --> $DIR/ptr_arg.rs:60:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -67,7 +67,7 @@ LL |     x.to_string()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:73:19
+  --> $DIR/ptr_arg.rs:68:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -90,7 +90,7 @@ LL |     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:81:44
+  --> $DIR/ptr_arg.rs:76:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -109,13 +109,13 @@ LL |     let c = y;
    |             ~
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:95:25
+  --> $DIR/ptr_arg.rs:90:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:148:21
+  --> $DIR/ptr_arg.rs:143:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -134,7 +134,7 @@ LL |         let _ = vec.to_owned().clone();
    |                 ~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:153:23
+  --> $DIR/ptr_arg.rs:148:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -153,7 +153,7 @@ LL |         let _ = path.to_path_buf().clone();
    |                 ~~~~~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:158:21
+  --> $DIR/ptr_arg.rs:153:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ declare_clippy_lint! {`
`27`	`27`	`/// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);`
`28`	`28`	/// ```
`29`	`29`	`pub IF_THEN_PANIC,`
`30`		`- style,`
	`30`	`+ pedantic,`
`31`	`31`	"`panic!` and only a `panic!` in `if`-then statement"
`32`	`32`	`}`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`#![deny(clippy::fallible_impl_from)]`
`2`		`-#![allow(clippy::if_then_panic)]`
`3`	`2`
`4`	`3`	`// docs example`
`5`	`4`	`struct Foo(i32);`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error: consider implementing `TryFrom` instead
`2`		`- --> $DIR/fallible_impl_from.rs:6:1`
	`2`	`+ --> $DIR/fallible_impl_from.rs:5:1`
`3`	`3`	`\|`
`4`	`4`	`LL \| / impl From<String> for Foo {`
`5`	`5`	`LL \| \| fn from(s: String) -> Self {`
`@@ -15,13 +15,13 @@ LL \| #![deny(clippy::fallible_impl_from)]`
`15`	`15`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`16`	`16`	= help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
`17`	`17`	`note: potential failure(s)`
`18`		`- --> $DIR/fallible_impl_from.rs:8:13`
	`18`	`+ --> $DIR/fallible_impl_from.rs:7:13`
`19`	`19`	`\|`
`20`	`20`	`LL \| Foo(s.parse().unwrap())`
`21`	`21`	`\| ^^^^^^^^^^^^^^^^^^`
`22`	`22`
`23`	`23`	error: consider implementing `TryFrom` instead
`24`		`- --> $DIR/fallible_impl_from.rs:27:1`
	`24`	`+ --> $DIR/fallible_impl_from.rs:26:1`
`25`	`25`	`\|`
`26`	`26`	`LL \| / impl From<usize> for Invalid {`
`27`	`27`	`LL \| \| fn from(i: usize) -> Invalid {`
`@@ -34,14 +34,14 @@ LL \| \| }`
`34`	`34`	`\|`
`35`	`35`	= help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
`36`	`36`	`note: potential failure(s)`
`37`		`- --> $DIR/fallible_impl_from.rs:30:13`
	`37`	`+ --> $DIR/fallible_impl_from.rs:29:13`
`38`	`38`	`\|`
`39`	`39`	`LL \| panic!();`
`40`	`40`	`\| ^^^^^^^^`
`41`	`41`	= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
`42`	`42`
`43`	`43`	error: consider implementing `TryFrom` instead
`44`		`- --> $DIR/fallible_impl_from.rs:36:1`
	`44`	`+ --> $DIR/fallible_impl_from.rs:35:1`
`45`	`45`	`\|`
`46`	`46`	`LL \| / impl From<Option<String>> for Invalid {`
`47`	`47`	`LL \| \| fn from(s: Option<String>) -> Invalid {`
`@@ -54,7 +54,7 @@ LL \| \| }`
`54`	`54`	`\|`
`55`	`55`	= help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
`56`	`56`	`note: potential failure(s)`
`57`		`- --> $DIR/fallible_impl_from.rs:38:17`
	`57`	`+ --> $DIR/fallible_impl_from.rs:37:17`
`58`	`58`	`\|`
`59`	`59`	`LL \| let s = s.unwrap();`
`60`	`60`	`\| ^^^^^^^^^^`
`@@ -68,7 +68,7 @@ LL \| panic!("{:?}", s);`
`68`	`68`	= note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
`69`	`69`
`70`	`70`	error: consider implementing `TryFrom` instead
`71`		`- --> $DIR/fallible_impl_from.rs:54:1`
	`71`	`+ --> $DIR/fallible_impl_from.rs:53:1`
`72`	`72`	`\|`
`73`	`73`	`LL \| / impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {`
`74`	`74`	`LL \| \| fn from(s: &'a mut <Box<u32> as ProjStrTrait>::ProjString) -> Invalid {`
`@@ -81,7 +81,7 @@ LL \| \| }`
`81`	`81`	`\|`
`82`	`82`	= help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
`83`	`83`	`note: potential failure(s)`
`84`		`- --> $DIR/fallible_impl_from.rs:56:12`
	`84`	`+ --> $DIR/fallible_impl_from.rs:55:12`
`85`	`85`	`\|`
`86`	`86`	`LL \| if s.parse::<u32>().ok().unwrap() != 42 {`
`87`	`87`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,31 +1,31 @@`
`1`	`1`	error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
`2`		`- --> $DIR/ptr_arg.rs:12:14`
	`2`	`+ --> $DIR/ptr_arg.rs:7:14`
`3`	`3`	`\|`
`4`	`4`	`LL \| fn do_vec(x: &Vec<i64>) {`
`5`	`5`	\| ^^^^^^^^^ help: change this to: `&[i64]`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::ptr-arg` implied by `-D warnings`
`8`	`8`
`9`	`9`	error: writing `&String` instead of `&str` involves a new object where a slice will do
`10`		`- --> $DIR/ptr_arg.rs:21:14`
	`10`	`+ --> $DIR/ptr_arg.rs:16:14`
`11`	`11`	`\|`
`12`	`12`	`LL \| fn do_str(x: &String) {`
`13`	`13`	\| ^^^^^^^ help: change this to: `&str`
`14`	`14`
`15`	`15`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`16`		`- --> $DIR/ptr_arg.rs:30:15`
	`16`	`+ --> $DIR/ptr_arg.rs:25:15`
`17`	`17`	`\|`
`18`	`18`	`LL \| fn do_path(x: &PathBuf) {`
`19`	`19`	\| ^^^^^^^^ help: change this to: `&Path`
`20`	`20`
`21`	`21`	error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
`22`		`- --> $DIR/ptr_arg.rs:43:18`
	`22`	`+ --> $DIR/ptr_arg.rs:38:18`
`23`	`23`	`\|`
`24`	`24`	`LL \| fn do_vec(x: &Vec<i64>);`
`25`	`25`	\| ^^^^^^^^^ help: change this to: `&[i64]`
`26`	`26`
`27`	`27`	error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
`28`		`- --> $DIR/ptr_arg.rs:56:14`
	`28`	`+ --> $DIR/ptr_arg.rs:51:14`
`29`	`29`	`\|`
`30`	`30`	`LL \| fn cloned(x: &Vec<u8>) -> Vec<u8> {`
`31`	`31`	`\| ^^^^^^^^`
`@@ -44,7 +44,7 @@ LL \| x.to_owned()`
`44`	`44`	`\|`
`45`	`45`
`46`	`46`	error: writing `&String` instead of `&str` involves a new object where a slice will do
`47`		`- --> $DIR/ptr_arg.rs:65:18`
	`47`	`+ --> $DIR/ptr_arg.rs:60:18`
`48`	`48`	`\|`
`49`	`49`	`LL \| fn str_cloned(x: &String) -> String {`
`50`	`50`	`\| ^^^^^^^`
`@@ -67,7 +67,7 @@ LL \| x.to_string()`
`67`	`67`	`\|`
`68`	`68`
`69`	`69`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`70`		`- --> $DIR/ptr_arg.rs:73:19`
	`70`	`+ --> $DIR/ptr_arg.rs:68:19`
`71`	`71`	`\|`
`72`	`72`	`LL \| fn path_cloned(x: &PathBuf) -> PathBuf {`
`73`	`73`	`\| ^^^^^^^^`
`@@ -90,7 +90,7 @@ LL \| x.to_path_buf()`
`90`	`90`	`\|`
`91`	`91`
`92`	`92`	error: writing `&String` instead of `&str` involves a new object where a slice will do
`93`		`- --> $DIR/ptr_arg.rs:81:44`
	`93`	`+ --> $DIR/ptr_arg.rs:76:44`
`94`	`94`	`\|`
`95`	`95`	`LL \| fn false_positive_capacity(x: &Vec<u8>, y: &String) {`
`96`	`96`	`\| ^^^^^^^`
`@@ -109,13 +109,13 @@ LL \| let c = y;`
`109`	`109`	`\| ~`
`110`	`110`
`111`	`111`	error: using a reference to `Cow` is not recommended
`112`		`- --> $DIR/ptr_arg.rs:95:25`
	`112`	`+ --> $DIR/ptr_arg.rs:90:25`
`113`	`113`	`\|`
`114`	`114`	`LL \| fn test_cow_with_ref(c: &Cow<[i32]>) {}`
`115`	`115`	\| ^^^^^^^^^^^ help: change this to: `&[i32]`
`116`	`116`
`117`	`117`	error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
`118`		`- --> $DIR/ptr_arg.rs:148:21`
	`118`	`+ --> $DIR/ptr_arg.rs:143:21`
`119`	`119`	`\|`
`120`	`120`	`LL \| fn foo_vec(vec: &Vec<u8>) {`
`121`	`121`	`\| ^^^^^^^^`
`@@ -134,7 +134,7 @@ LL \| let _ = vec.to_owned().clone();`
`134`	`134`	`\| ~~~~~~~~~~~~~~`
`135`	`135`
`136`	`136`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`137`		`- --> $DIR/ptr_arg.rs:153:23`
	`137`	`+ --> $DIR/ptr_arg.rs:148:23`
`138`	`138`	`\|`
`139`	`139`	`LL \| fn foo_path(path: &PathBuf) {`
`140`	`140`	`\| ^^^^^^^^`
`@@ -153,7 +153,7 @@ LL \| let _ = path.to_path_buf().clone();`
`153`	`153`	`\| ~~~~~~~~~~~~~~~~~~`
`154`	`154`
`155`	`155`	error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
`156`		`- --> $DIR/ptr_arg.rs:158:21`
	`156`	`+ --> $DIR/ptr_arg.rs:153:21`
`157`	`157`	`\|`
`158`	`158`	`LL \| fn foo_str(str: &PathBuf) {`
`159`	`159`	`\| ^^^^^^^^`