src/tools/clippy/tests/ui/useless_conversion.stderr

error: useless conversion to the same type: `T`
  --> tests/ui/useless_conversion.rs:10:13
   |
LL |     let _ = T::from(val);
   |             ^^^^^^^^^^^^ help: consider removing `T::from()`: `val`
   |
note: the lint level is defined here
  --> tests/ui/useless_conversion.rs:1:9
   |
LL | #![deny(clippy::useless_conversion)]
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^

error: useless conversion to the same type: `T`
  --> tests/ui/useless_conversion.rs:12:5
   |
LL |     val.into()
   |     ^^^^^^^^^^ help: consider removing `.into()`: `val`

error: useless conversion to the same type: `i32`
  --> tests/ui/useless_conversion.rs:25:22
   |
LL |         let _: i32 = 0i32.into();
   |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`

error: useless conversion to the same type: `std::str::Lines<'_>`
  --> tests/ui/useless_conversion.rs:56:22
   |
LL |     if Some("ok") == lines.into_iter().next() {}
   |                      ^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `lines`

error: useless conversion to the same type: `std::str::Lines<'_>`
  --> tests/ui/useless_conversion.rs:62:21
   |
LL |     let mut lines = text.lines().into_iter();
   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`

error: useless conversion to the same type: `std::str::Lines<'_>`
  --> tests/ui/useless_conversion.rs:69:22
   |
LL |     if Some("ok") == text.lines().into_iter().next() {}
   |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`

error: useless conversion to the same type: `std::iter::Empty<i32>`
  --> tests/ui/useless_conversion.rs:76:13
   |
LL |     let _ = NUMBERS.into_iter().next();
   |             ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`

error: useless conversion to the same type: `std::iter::Empty<i32>`
  --> tests/ui/useless_conversion.rs:82:17
   |
LL |     let mut n = NUMBERS.into_iter();
   |                 ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:126:17
   |
LL |         consume(items.into_iter());
   |                 ^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:122:28
   |
LL |         fn consume(_: impl IntoIterator) {}
   |                            ^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -         consume(items.into_iter());
LL +         consume(*items);
   |

error: useless conversion to the same type: `std::string::String`
  --> tests/ui/useless_conversion.rs:139: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`
  --> tests/ui/useless_conversion.rs:141: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`
  --> tests/ui/useless_conversion.rs:143: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`
  --> tests/ui/useless_conversion.rs:145:13
   |
LL |     let _ = String::from(format!("A: {:04}", 123));
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`

error: useless conversion to the same type: `std::str::Lines<'_>`
  --> tests/ui/useless_conversion.rs:147:13
   |
LL |     let _ = "".lines().into_iter();
   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`

error: useless conversion to the same type: `std::vec::IntoIter<i32>`
  --> tests/ui/useless_conversion.rs:149:13
   |
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`
  --> tests/ui/useless_conversion.rs:151:21
   |
LL |     let _: String = format!("Hello {}", "world").into();
   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`

error: useless conversion to the same type: `i32`
  --> tests/ui/useless_conversion.rs:157:13
   |
LL |     let _ = i32::from(a + b) * 3;
   |             ^^^^^^^^^^^^^^^^ help: consider removing `i32::from()`: `(a + b)`

error: useless conversion to the same type: `Foo<'a'>`
  --> tests/ui/useless_conversion.rs:164:23
   |
LL |     let _: Foo<'a'> = s2.into();
   |                       ^^^^^^^^^ help: consider removing `.into()`: `s2`

error: useless conversion to the same type: `Foo<'a'>`
  --> tests/ui/useless_conversion.rs:167:13
   |
LL |     let _ = Foo::<'a'>::from(s3);
   |             ^^^^^^^^^^^^^^^^^^^^ help: consider removing `Foo::<'a'>::from()`: `s3`

error: useless conversion to the same type: `std::vec::IntoIter<Foo<'a'>>`
  --> tests/ui/useless_conversion.rs:170:13
   |
LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:203:7
   |
LL |     b(vec![1, 2].into_iter());
   |       ^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:193:13
   |
LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
   |             ^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -     b(vec![1, 2].into_iter());
LL +     b(vec![1, 2]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:205:7
   |
LL |     c(vec![1, 2].into_iter());
   |       ^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:194:18
   |
LL |     fn c(_: impl IntoIterator<Item = i32>) {}
   |                  ^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -     c(vec![1, 2].into_iter());
LL +     c(vec![1, 2]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:207:7
   |
LL |     d(vec![1, 2].into_iter());
   |       ^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:197:12
   |
LL |         T: IntoIterator<Item = i32>,
   |            ^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -     d(vec![1, 2].into_iter());
LL +     d(vec![1, 2]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:211:7
   |
LL |     b(vec![1, 2].into_iter().into_iter());
   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:193:13
   |
LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
   |             ^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`s
   |
LL -     b(vec![1, 2].into_iter().into_iter());
LL +     b(vec![1, 2]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:213:7
   |
LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:193:13
   |
LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
   |             ^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`s
   |
LL -     b(vec![1, 2].into_iter().into_iter().into_iter());
LL +     b(vec![1, 2]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:260:24
   |
LL |         foo2::<i32, _>([1, 2, 3].into_iter());
   |                        ^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:239:12
   |
LL |         I: IntoIterator<Item = i32> + Helper<X>,
   |            ^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -         foo2::<i32, _>([1, 2, 3].into_iter());
LL +         foo2::<i32, _>([1, 2, 3]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:269:14
   |
LL |         foo3([1, 2, 3].into_iter());
   |              ^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:248:12
   |
LL |         I: IntoIterator<Item = i32>,
   |            ^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -         foo3([1, 2, 3].into_iter());
LL +         foo3([1, 2, 3]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:279:16
   |
LL |         S1.foo([1, 2].into_iter());
   |                ^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:276:27
   |
LL |             pub fn foo<I: IntoIterator>(&self, _: I) {}
   |                           ^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -         S1.foo([1, 2].into_iter());
LL +         S1.foo([1, 2]);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:299:44
   |
LL |         v0.into_iter().interleave_shortest(v1.into_iter());
   |                                            ^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:286:20
   |
LL |                 J: IntoIterator,
   |                    ^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -         v0.into_iter().interleave_shortest(v1.into_iter());
LL +         v0.into_iter().interleave_shortest(v1);
   |

error: useless conversion to the same type: `()`
  --> tests/ui/useless_conversion.rs:327:58
   |
LL |     let _: Result<(), std::io::Error> = test_issue_3913().map(Into::into);
   |                                                          ^^^^^^^^^^^^^^^^ help: consider removing

error: useless conversion to the same type: `std::io::Error`
  --> tests/ui/useless_conversion.rs:330:58
   |
LL |     let _: Result<(), std::io::Error> = test_issue_3913().map_err(Into::into);
   |                                                          ^^^^^^^^^^^^^^^^^^^^ help: consider removing

error: useless conversion to the same type: `()`
  --> tests/ui/useless_conversion.rs:333:58
   |
LL |     let _: Result<(), std::io::Error> = test_issue_3913().map(From::from);
   |                                                          ^^^^^^^^^^^^^^^^ help: consider removing

error: useless conversion to the same type: `std::io::Error`
  --> tests/ui/useless_conversion.rs:336:58
   |
LL |     let _: Result<(), std::io::Error> = test_issue_3913().map_err(From::from);
   |                                                          ^^^^^^^^^^^^^^^^^^^^ help: consider removing

error: useless conversion to the same type: `()`
  --> tests/ui/useless_conversion.rs:340:31
   |
LL |     let _: ControlFlow<()> = c.map_break(Into::into);
   |                               ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing

error: useless conversion to the same type: `()`
  --> tests/ui/useless_conversion.rs:344:31
   |
LL |     let _: ControlFlow<()> = c.map_continue(Into::into);
   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing

error: useless conversion to the same type: `u32`
  --> tests/ui/useless_conversion.rs:358:41
   |
LL |     let _: Vec<u32> = [1u32].into_iter().map(Into::into).collect();
   |                                         ^^^^^^^^^^^^^^^^ help: consider removing

error: useless conversion to the same type: `T`
  --> tests/ui/useless_conversion.rs:369:18
   |
LL |     x.into_iter().map(Into::into).collect()
   |                  ^^^^^^^^^^^^^^^^ help: consider removing

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:385:29
   |
LL |             takes_into_iter(self.my_field.into_iter());
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:374:32
   |
LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -             takes_into_iter(self.my_field.into_iter());
LL +             takes_into_iter(&self.my_field);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:393:29
   |
LL |             takes_into_iter(self.my_field.into_iter());
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:374:32
   |
LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -             takes_into_iter(self.my_field.into_iter());
LL +             takes_into_iter(&mut self.my_field);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:402:29
   |
LL |             takes_into_iter(self.my_field.into_iter());
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:374:32
   |
LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -             takes_into_iter(self.my_field.into_iter());
LL +             takes_into_iter(*self.my_field);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:411:29
   |
LL |             takes_into_iter(self.my_field.into_iter());
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:374:32
   |
LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -             takes_into_iter(self.my_field.into_iter());
LL +             takes_into_iter(&*self.my_field);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:420:29
   |
LL |             takes_into_iter(self.my_field.into_iter());
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:374:32
   |
LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -             takes_into_iter(self.my_field.into_iter());
LL +             takes_into_iter(&mut *self.my_field);
   |

error: useless conversion to the same type: `std::iter::Empty<u32>`
  --> tests/ui/useless_conversion.rs:433:5
   |
LL |     R.into_iter().for_each(|_x| {});
   |     ^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `R`

error: useless conversion to the same type: `std::iter::Empty<u32>`
  --> tests/ui/useless_conversion.rs:435:13
   |
LL |     let _ = R.into_iter().map(|_x| 0);
   |             ^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `R`

error: useless conversion to the same type: `std::ops::Range<i32>`
  --> tests/ui/useless_conversion.rs:458:14
   |
LL |     for _ in (0..10).into_iter() {}
   |              ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `(0..10)`

error: useless conversion to the same type: `std::ops::RangeInclusive<i32>`
  --> tests/ui/useless_conversion.rs:459:14
   |
LL |     for _ in (0..=10).into_iter() {}
   |              ^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `(0..=10)`

error: useless conversion to the same type: `std::ops::RangeFrom<i32>`
  --> tests/ui/useless_conversion.rs:460:14
   |
LL |     for _ in (0..).into_iter() {
   |              ^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `(0..)`

error: useless conversion to the same type: `std::slice::Iter<'_, i32>`
  --> tests/ui/useless_conversion.rs:473:14
   |
LL |     for _ in mac!(iter [1, 2]).into_iter() {}
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `mac!(iter [1, 2])`

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:486:27
   |
LL |     takes_into_iter_usize(b.into_iter());
   |                           ^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:477:34
   |
LL | fn takes_into_iter_usize(_: impl IntoIterator<Item = usize>) {}
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -     takes_into_iter_usize(b.into_iter());
LL +     takes_into_iter_usize(b);
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:495:31
   |
LL |         takes_into_iter_usize(b.clone().into_iter());
   |                               ^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:477:34
   |
LL | fn takes_into_iter_usize(_: impl IntoIterator<Item = usize>) {}
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -         takes_into_iter_usize(b.clone().into_iter());
LL +         takes_into_iter_usize(b.clone());
   |

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
  --> tests/ui/useless_conversion.rs:503:34
   |
LL |     takes_into_iter_usize_result(b.clone().into_iter())?;
   |                                  ^^^^^^^^^^^^^^^^^^^^^
   |
note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
  --> tests/ui/useless_conversion.rs:478:41
   |
LL | fn takes_into_iter_usize_result(_: impl IntoIterator<Item = usize>) -> Result<(), ()> {
   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider removing the `.into_iter()`
   |
LL -     takes_into_iter_usize_result(b.clone().into_iter())?;
LL +     takes_into_iter_usize_result(b.clone())?;
   |

error: aborting due to 51 previous errors