Update String's new path in clippy tests

zachs18 · zachs18 · commit 95708daad358 · 2025-02-03T00:06:12.000-06:00
diff --git a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
@@ -1,4 +1,4 @@
-error: holding a disallowed type across an await point `std::string::String`
+error: holding a disallowed type across an await point `std::string::string::String`
   --> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:5:9
    |
 LL |     let _x = String::from("hello");
@@ -14,7 +14,7 @@ error: holding a disallowed type across an await point `std::net::Ipv4Addr`
 LL |     let x = Ipv4Addr::new(127, 0, 0, 1);
    |         ^
 
-error: holding a disallowed type across an await point `std::string::String`
+error: holding a disallowed type across an await point `std::string::string::String`
   --> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:33:13
    |
 LL |         let _x = String::from("hi!");
diff --git a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/clippy.toml b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/clippy.toml
@@ -1,4 +1,4 @@
 await-holding-invalid-types = [
-    { path = "std::string::String", reason = "strings are bad" },
+    { path = "std::string::string::String", reason = "strings are bad" },
     "std::net::Ipv4Addr",
 ]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3969.rs b/src/tools/clippy/tests/ui/crashes/ice-3969.rs
@@ -40,7 +40,7 @@ where
 fn use_op(s: String) -> String
 where
     String: ::std::ops::Neg<Output = String>,
-    //~^ ERROR: trait bound std::string::String: std::ops::Neg does not depend on any type
+    //~^ ERROR: trait bound std::string::string::String: std::ops::Neg does not depend on any type
 {
     -s
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3969.stderr b/src/tools/clippy/tests/ui/crashes/ice-3969.stderr
@@ -19,7 +19,7 @@ error: trait bound str: std::marker::Sized does not depend on any type or lifeti
 LL |     str: Sized,
    |          ^^^^^
 
-error: trait bound std::string::String: std::ops::Neg does not depend on any type or lifetime parameters
+error: trait bound std::string::string::String: std::ops::Neg does not depend on any type or lifetime parameters
   --> tests/ui/crashes/ice-3969.rs:42:13
    |
 LL |     String: ::std::ops::Neg<Output = String>,
diff --git a/src/tools/clippy/tests/ui/from_over_into.stderr b/src/tools/clippy/tests/ui/from_over_into.stderr
@@ -6,7 +6,7 @@ LL | impl Into<StringWrapper> for String {
    |
    = note: `-D clippy::from-over-into` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::from_over_into)]`
-help: replace the `Into` implementation with `From<std::string::String>`
+help: replace the `Into` implementation with `From<std::string::string::String>`
    |
 LL ~ impl From<String> for StringWrapper {
 LL ~     fn from(val: String) -> Self {
@@ -19,7 +19,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
 LL | impl Into<SelfType> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace the `Into` implementation with `From<std::string::String>`
+help: replace the `Into` implementation with `From<std::string::string::String>`
    |
 LL ~ impl From<String> for SelfType {
 LL ~     fn from(val: String) -> Self {
diff --git a/src/tools/clippy/tests/ui/from_over_into_unfixable.stderr b/src/tools/clippy/tests/ui/from_over_into_unfixable.stderr
@@ -4,7 +4,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
 LL | impl Into<InMacro> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: replace the `Into` implementation with `From<std::string::String>`
+   = help: replace the `Into` implementation with `From<std::string::string::String>`
    = note: `-D clippy::from-over-into` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::from_over_into)]`
 
diff --git a/src/tools/clippy/tests/ui/inefficient_to_string.stderr b/src/tools/clippy/tests/ui/inefficient_to_string.stderr
@@ -19,21 +19,21 @@ LL |     let _: String = rrrstr.to_string();
    |
    = help: `&&str` implements `ToString` through a slower blanket impl, but `str` has a fast specialization of `ToString`
 
-error: calling `to_string` on `&&std::string::String`
+error: calling `to_string` on `&&std::string::string::String`
   --> tests/ui/inefficient_to_string.rs:19:21
    |
 LL |     let _: String = rrstring.to_string();
    |                     ^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(*rrstring).to_string()`
    |
-   = help: `&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
+   = help: `&std::string::string::String` implements `ToString` through a slower blanket impl, but `std::string::string::String` has a fast specialization of `ToString`
 
-error: calling `to_string` on `&&&std::string::String`
+error: calling `to_string` on `&&&std::string::string::String`
   --> tests/ui/inefficient_to_string.rs:20:21
    |
 LL |     let _: String = rrrstring.to_string();
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrstring).to_string()`
    |
-   = help: `&&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
+   = help: `&&std::string::string::String` implements `ToString` through a slower blanket impl, but `std::string::string::String` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&std::borrow::Cow<'_, str>`
   --> tests/ui/inefficient_to_string.rs:28:21
diff --git a/src/tools/clippy/tests/ui/mem_forget.rs b/src/tools/clippy/tests/ui/mem_forget.rs
@@ -28,7 +28,7 @@ fn main() {
     let string = String::new();
     std::mem::forget(string);
     //~^ ERROR: usage of `mem::forget` on type with `Drop` fields
-    //~| NOTE: argument has type `std::string::String`
+    //~| NOTE: argument has type `std::string::string::String`
 
     std::mem::forget(7);
 }
diff --git a/src/tools/clippy/tests/ui/mem_forget.stderr b/src/tools/clippy/tests/ui/mem_forget.stderr
@@ -30,7 +30,7 @@ error: usage of `mem::forget` on type with `Drop` fields
 LL |     std::mem::forget(string);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: argument has type `std::string::String`
+   = note: argument has type `std::string::string::String`
 
 error: aborting due to 4 previous errors
 
diff --git a/src/tools/clippy/tests/ui/useless_conversion.stderr b/src/tools/clippy/tests/ui/useless_conversion.stderr
@@ -52,25 +52,25 @@ error: useless conversion to the same type: `std::ops::Range<i32>`
 LL |     let mut n = NUMBERS.into_iter();
    |                 ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion.rs:136:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion.rs:137:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion.rs:138:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion.rs:139:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
@@ -88,7 +88,7 @@ error: useless conversion to the same type: `std::vec::IntoIter<i32>`
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion.rs:142:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
diff --git a/src/tools/clippy/tests/ui/useless_conversion_try.rs b/src/tools/clippy/tests/ui/useless_conversion_try.rs
@@ -32,19 +32,19 @@ fn main() {
         let _: String = "foo".try_into().unwrap();
     }
     let _: String = "foo".to_string().try_into().unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ ERROR: useless conversion to the same type: `std::string::string::String`
     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ ERROR: useless conversion to the same type: `std::string::string::String`
     let _ = String::try_from("foo".to_string()).unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ ERROR: useless conversion to the same type: `std::string::string::String`
     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ ERROR: useless conversion to the same type: `std::string::string::String`
     let _: String = format!("Hello {}", "world").try_into().unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ ERROR: useless conversion to the same type: `std::string::string::String`
     let _: String = String::new().try_into().unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ ERROR: useless conversion to the same type: `std::string::string::String`
     let _: String = match String::from("_").try_into() {
-        //~^ ERROR: useless conversion to the same type: `std::string::String`
+        //~^ ERROR: useless conversion to the same type: `std::string::string::String`
         Ok(a) => a,
         Err(_) => String::new(),
     };
diff --git a/src/tools/clippy/tests/ui/useless_conversion_try.stderr b/src/tools/clippy/tests/ui/useless_conversion_try.stderr
@@ -19,55 +19,55 @@ LL |     val.try_into().unwrap()
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion_try.rs:34:21
    |
 LL |     let _: String = "foo".to_string().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion_try.rs:36:21
    |
 LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `TryFrom::try_from()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion_try.rs:38:13
    |
 LL |     let _ = String::try_from("foo".to_string()).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `String::try_from()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion_try.rs:40:13
    |
 LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `String::try_from()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion_try.rs:42:21
    |
 LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion_try.rs:44:21
    |
 LL |     let _: String = String::new().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type: `std::string::String`
+error: useless conversion to the same type: `std::string::string::String`
   --> tests/ui/useless_conversion_try.rs:46:27
    |
 LL |     let _: String = match String::from("_").try_into() {

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		-error: holding a disallowed type across an await point `std::string::String`
	`1`	+error: holding a disallowed type across an await point `std::string::string::String`
`2`	`2`	`--> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:5:9`
`3`	`3`	`\|`
`4`	`4`	`LL \| let _x = String::from("hello");`
@@ -14,7 +14,7 @@ error: holding a disallowed type across an await point `std::net::Ipv4Addr`
`14`	`14`	`LL \| let x = Ipv4Addr::new(127, 0, 0, 1);`
`15`	`15`	`\| ^`
`16`	`16`
`17`		-error: holding a disallowed type across an await point `std::string::String`
	`17`	+error: holding a disallowed type across an await point `std::string::string::String`
`18`	`18`	`--> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:33:13`
`19`	`19`	`\|`
`20`	`20`	`LL \| let _x = String::from("hi!");`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`	`1`	`await-holding-invalid-types = [`
`2`		`- { path = "std::string::String", reason = "strings are bad" },`
	`2`	`+ { path = "std::string::string::String", reason = "strings are bad" },`
`3`	`3`	`"std::net::Ipv4Addr",`
`4`	`4`	`]`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ where`
`40`	`40`	`fn use_op(s: String) -> String`
`41`	`41`	`where`
`42`	`42`	`String: ::std::ops::Neg<Output = String>,`
`43`		`- //~^ ERROR: trait bound std::string::String: std::ops::Neg does not depend on any type`
	`43`	`+ //~^ ERROR: trait bound std::string::string::String: std::ops::Neg does not depend on any type`
`44`	`44`	`{`
`45`	`45`	`-s`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ error: trait bound str: std::marker::Sized does not depend on any type or lifeti`
`19`	`19`	`LL \| str: Sized,`
`20`	`20`	`\| ^^^^^`
`21`	`21`
`22`		`-error: trait bound std::string::String: std::ops::Neg does not depend on any type or lifetime parameters`
	`22`	`+error: trait bound std::string::string::String: std::ops::Neg does not depend on any type or lifetime parameters`
`23`	`23`	`--> tests/ui/crashes/ice-3969.rs:42:13`
`24`	`24`	`\|`
`25`	`25`	`LL \| String: ::std::ops::Neg<Output = String>,`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ LL \| impl Into<StringWrapper> for String {`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::from-over-into` implied by `-D warnings`
`8`	`8`	= help: to override `-D warnings` add `#[allow(clippy::from_over_into)]`
`9`		-help: replace the `Into` implementation with `From<std::string::String>`
	`9`	+help: replace the `Into` implementation with `From<std::string::string::String>`
`10`	`10`	`\|`
`11`	`11`	`LL ~ impl From<String> for StringWrapper {`
`12`	`12`	`LL ~ fn from(val: String) -> Self {`
@@ -19,7 +19,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
`19`	`19`	`LL \| impl Into<SelfType> for String {`
`20`	`20`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`21`	`21`	`\|`
`22`		-help: replace the `Into` implementation with `From<std::string::String>`
	`22`	+help: replace the `Into` implementation with `From<std::string::string::String>`
`23`	`23`	`\|`
`24`	`24`	`LL ~ impl From<String> for SelfType {`
`25`	`25`	`LL ~ fn from(val: String) -> Self {`
Original file line number	Diff line number	Diff line change
@@ -4,7 +4,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
`4`	`4`	`LL \| impl Into<InMacro> for String {`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`		- = help: replace the `Into` implementation with `From<std::string::String>`
	`7`	+ = help: replace the `Into` implementation with `From<std::string::string::String>`
`8`	`8`	= note: `-D clippy::from-over-into` implied by `-D warnings`
`9`	`9`	= help: to override `-D warnings` add `#[allow(clippy::from_over_into)]`
`10`	`10`
Original file line number	Diff line number	Diff line change
`@@ -19,21 +19,21 @@ LL \| let _: String = rrrstr.to_string();`
`19`	`19`	`\|`
`20`	`20`	= help: `&&str` implements `ToString` through a slower blanket impl, but `str` has a fast specialization of `ToString`
`21`	`21`
`22`		-error: calling `to_string` on `&&std::string::String`
	`22`	+error: calling `to_string` on `&&std::string::string::String`
`23`	`23`	`--> tests/ui/inefficient_to_string.rs:19:21`
`24`	`24`	`\|`
`25`	`25`	`LL \| let _: String = rrstring.to_string();`
`26`	`26`	\| ^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(*rrstring).to_string()`
`27`	`27`	`\|`
`28`		- = help: `&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
	`28`	+ = help: `&std::string::string::String` implements `ToString` through a slower blanket impl, but `std::string::string::String` has a fast specialization of `ToString`
`29`	`29`
`30`		-error: calling `to_string` on `&&&std::string::String`
	`30`	+error: calling `to_string` on `&&&std::string::string::String`
`31`	`31`	`--> tests/ui/inefficient_to_string.rs:20:21`
`32`	`32`	`\|`
`33`	`33`	`LL \| let _: String = rrrstring.to_string();`
`34`	`34`	\| ^^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrstring).to_string()`
`35`	`35`	`\|`
`36`		- = help: `&&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
	`36`	+ = help: `&&std::string::string::String` implements `ToString` through a slower blanket impl, but `std::string::string::String` has a fast specialization of `ToString`
`37`	`37`
`38`	`38`	error: calling `to_string` on `&&std::borrow::Cow<'_, str>`
`39`	`39`	`--> tests/ui/inefficient_to_string.rs:28:21`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ fn main() {`
`28`	`28`	`let string = String::new();`
`29`	`29`	`std::mem::forget(string);`
`30`	`30`	//~^ ERROR: usage of `mem::forget` on type with `Drop` fields
`31`		- //~\| NOTE: argument has type `std::string::String`
	`31`	+ //~\| NOTE: argument has type `std::string::string::String`
`32`	`32`
`33`	`33`	`std::mem::forget(7);`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
@@ -30,7 +30,7 @@ error: usage of `mem::forget` on type with `Drop` fields
`30`	`30`	`LL \| std::mem::forget(string);`
`31`	`31`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`32`	`32`	`\|`
`33`		- = note: argument has type `std::string::String`
	`33`	+ = note: argument has type `std::string::string::String`
`34`	`34`
`35`	`35`	`error: aborting due to 4 previous errors`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -19,55 +19,55 @@ LL \| val.try_into().unwrap()`
`19`	`19`	`\|`
`20`	`20`	= help: consider removing `.try_into()`
`21`	`21`
`22`		-error: useless conversion to the same type: `std::string::String`
	`22`	+error: useless conversion to the same type: `std::string::string::String`
`23`	`23`	`--> tests/ui/useless_conversion_try.rs:34:21`
`24`	`24`	`\|`
`25`	`25`	`LL \| let _: String = "foo".to_string().try_into().unwrap();`
`26`	`26`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`27`	`27`	`\|`
`28`	`28`	= help: consider removing `.try_into()`
`29`	`29`
`30`		-error: useless conversion to the same type: `std::string::String`
	`30`	+error: useless conversion to the same type: `std::string::string::String`
`31`	`31`	`--> tests/ui/useless_conversion_try.rs:36:21`
`32`	`32`	`\|`
`33`	`33`	`LL \| let _: String = TryFrom::try_from("foo".to_string()).unwrap();`
`34`	`34`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`35`	`35`	`\|`
`36`	`36`	= help: consider removing `TryFrom::try_from()`
`37`	`37`
`38`		-error: useless conversion to the same type: `std::string::String`
	`38`	+error: useless conversion to the same type: `std::string::string::String`
`39`	`39`	`--> tests/ui/useless_conversion_try.rs:38:13`
`40`	`40`	`\|`
`41`	`41`	`LL \| let _ = String::try_from("foo".to_string()).unwrap();`
`42`	`42`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`43`	`43`	`\|`
`44`	`44`	= help: consider removing `String::try_from()`
`45`	`45`
`46`		-error: useless conversion to the same type: `std::string::String`
	`46`	+error: useless conversion to the same type: `std::string::string::String`
`47`	`47`	`--> tests/ui/useless_conversion_try.rs:40:13`
`48`	`48`	`\|`
`49`	`49`	`LL \| let _ = String::try_from(format!("A: {:04}", 123)).unwrap();`
`50`	`50`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`51`	`51`	`\|`
`52`	`52`	= help: consider removing `String::try_from()`
`53`	`53`
`54`		-error: useless conversion to the same type: `std::string::String`
	`54`	+error: useless conversion to the same type: `std::string::string::String`
`55`	`55`	`--> tests/ui/useless_conversion_try.rs:42:21`
`56`	`56`	`\|`
`57`	`57`	`LL \| let _: String = format!("Hello {}", "world").try_into().unwrap();`
`58`	`58`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`59`	`59`	`\|`
`60`	`60`	= help: consider removing `.try_into()`
`61`	`61`
`62`		-error: useless conversion to the same type: `std::string::String`
	`62`	+error: useless conversion to the same type: `std::string::string::String`
`63`	`63`	`--> tests/ui/useless_conversion_try.rs:44:21`
`64`	`64`	`\|`
`65`	`65`	`LL \| let _: String = String::new().try_into().unwrap();`
`66`	`66`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`67`	`67`	`\|`
`68`	`68`	= help: consider removing `.try_into()`
`69`	`69`
`70`		-error: useless conversion to the same type: `std::string::String`
	`70`	+error: useless conversion to the same type: `std::string::string::String`
`71`	`71`	`--> tests/ui/useless_conversion_try.rs:46:27`
`72`	`72`	`\|`
`73`	`73`	`LL \| let _: String = match String::from("_").try_into() {`