src/tools/clippy/tests/ui/unnecessary_to_owned.stderr - toolchain/rustc - Git at Google

 error: redundant clone
   --> $DIR/unnecessary_to_owned.rs:154:64
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                                                                ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
   --> $DIR/unnecessary_to_owned.rs:154:20
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`

 error: redundant clone
   --> $DIR/unnecessary_to_owned.rs:155:40
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                                        ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
   --> $DIR/unnecessary_to_owned.rs:155:21
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                     ^^^^^^^^^^^^^^^^^^^

 error: redundant clone
   --> $DIR/unnecessary_to_owned.rs:156:48
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                                                ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
   --> $DIR/unnecessary_to_owned.rs:156:19
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error: redundant clone
   --> $DIR/unnecessary_to_owned.rs:157:35
    |
 LL |     require_str(&String::from("x").to_string());
    |                                   ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
   --> $DIR/unnecessary_to_owned.rs:157:18
    |
 LL |     require_str(&String::from("x").to_string());
    |                  ^^^^^^^^^^^^^^^^^

 error: redundant clone
   --> $DIR/unnecessary_to_owned.rs:158:39
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                                       ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
   --> $DIR/unnecessary_to_owned.rs:158:20
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^

 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:63:36
    |
 LL |     require_c_str(&Cow::from(c_str).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
    |
    = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:64:19
    |
 LL |     require_c_str(&c_str.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `c_str`

 error: unnecessary use of `to_os_string`
   --> $DIR/unnecessary_to_owned.rs:66:20
    |
 LL |     require_os_str(&os_str.to_os_string());
    |                    ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`

 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:67:38
    |
 LL |     require_os_str(&Cow::from(os_str).into_owned());
    |                                      ^^^^^^^^^^^^^ help: remove this

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:68:20
    |
 LL |     require_os_str(&os_str.to_owned());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `os_str`

 error: unnecessary use of `to_path_buf`
   --> $DIR/unnecessary_to_owned.rs:70:18
    |
 LL |     require_path(&path.to_path_buf());
    |                  ^^^^^^^^^^^^^^^^^^^ help: use: `path`

 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:71:34
    |
 LL |     require_path(&Cow::from(path).into_owned());
    |                                  ^^^^^^^^^^^^^ help: remove this

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:72:18
    |
 LL |     require_path(&path.to_owned());
    |                  ^^^^^^^^^^^^^^^^ help: use: `path`

 error: unnecessary use of `to_string`
   --> $DIR/unnecessary_to_owned.rs:74:17
    |
 LL |     require_str(&s.to_string());
    |                 ^^^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:75:30
    |
 LL |     require_str(&Cow::from(s).into_owned());
    |                              ^^^^^^^^^^^^^ help: remove this

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:76:17
    |
 LL |     require_str(&s.to_owned());
    |                 ^^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_string`
   --> $DIR/unnecessary_to_owned.rs:77:17
    |
 LL |     require_str(&x_ref.to_string());
    |                 ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:79:19
    |
 LL |     require_slice(&slice.to_vec());
    |                   ^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:80:36
    |
 LL |     require_slice(&Cow::from(slice).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:81:19
    |
 LL |     require_slice(&array.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:82:19
    |
 LL |     require_slice(&array_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:83:19
    |
 LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:86:42
    |
 LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
    |                                          ^^^^^^^^^^^^^ help: remove this

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:89:25
    |
 LL |     require_deref_c_str(c_str.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `c_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:90:26
    |
 LL |     require_deref_os_str(os_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^^ help: use: `os_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:91:24
    |
 LL |     require_deref_path(path.to_owned());
    |                        ^^^^^^^^^^^^^^^ help: use: `path`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:92:23
    |
 LL |     require_deref_str(s.to_owned());
    |                       ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:93:25
    |
 LL |     require_deref_slice(slice.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:95:30
    |
 LL |     require_impl_deref_c_str(c_str.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `c_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:96:31
    |
 LL |     require_impl_deref_os_str(os_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^^ help: use: `os_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:97:29
    |
 LL |     require_impl_deref_path(path.to_owned());
    |                             ^^^^^^^^^^^^^^^ help: use: `path`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:98:28
    |
 LL |     require_impl_deref_str(s.to_owned());
    |                            ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:99:30
    |
 LL |     require_impl_deref_slice(slice.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:101:29
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:101:43
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                                           ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:102:29
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                             ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:102:47
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                                               ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:104:26
    |
 LL |     require_as_ref_c_str(c_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `c_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:105:27
    |
 LL |     require_as_ref_os_str(os_str.to_owned());
    |                           ^^^^^^^^^^^^^^^^^ help: use: `os_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:106:25
    |
 LL |     require_as_ref_path(path.to_owned());
    |                         ^^^^^^^^^^^^^^^ help: use: `path`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:107:24
    |
 LL |     require_as_ref_str(s.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:108:24
    |
 LL |     require_as_ref_str(x.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `&x`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:109:26
    |
 LL |     require_as_ref_slice(array.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `array`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:110:26
    |
 LL |     require_as_ref_slice(array_ref.to_owned());
    |                          ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:111:26
    |
 LL |     require_as_ref_slice(slice.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:113:31
    |
 LL |     require_impl_as_ref_c_str(c_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `c_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:114:32
    |
 LL |     require_impl_as_ref_os_str(os_str.to_owned());
    |                                ^^^^^^^^^^^^^^^^^ help: use: `os_str`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:115:30
    |
 LL |     require_impl_as_ref_path(path.to_owned());
    |                              ^^^^^^^^^^^^^^^ help: use: `path`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:116:29
    |
 LL |     require_impl_as_ref_str(s.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:117:29
    |
 LL |     require_impl_as_ref_str(x.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `&x`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:118:31
    |
 LL |     require_impl_as_ref_slice(array.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `array`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:119:31
    |
 LL |     require_impl_as_ref_slice(array_ref.to_owned());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:120:31
    |
 LL |     require_impl_as_ref_slice(slice.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:122:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:122:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `array`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:123:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:123:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                                            ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:124:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:124:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:125:30
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `array`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:125:48
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:126:30
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:126:52
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                                                    ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:127:30
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:127:48
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`

 error: unnecessary use of `to_string`
   --> $DIR/unnecessary_to_owned.rs:129:20
    |
 LL |     let _ = x.join(&x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:131:13
    |
 LL |     let _ = slice.to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:132:13
    |
 LL |     let _ = slice.to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:133:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:134:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:136:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:137:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:138:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:139:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:201:14
    |
 LL |     for t in file_types.to_vec() {
    |              ^^^^^^^^^^^^^^^^^^^
    |
 help: use
    |
 LL |     for t in file_types {
    |              ~~~~~~~~~~
 help: remove this `&`
    |
 LL -         let path = match get_file_path(&t) {
 LL +         let path = match get_file_path(t) {
    |

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:224:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().cloned()`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:229:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().copied()`

 error: unnecessary use of `to_string`
   --> $DIR/unnecessary_to_owned.rs:276:24
    |
 LL |         Box::new(build(y.to_string()))
    |                        ^^^^^^^^^^^^^ help: use: `y`

 error: unnecessary use of `to_string`
   --> $DIR/unnecessary_to_owned.rs:384:12
    |
 LL |         id("abc".to_string())
    |            ^^^^^^^^^^^^^^^^^ help: use: `"abc"`

 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:527:37
    |
 LL |         IntoFuture::into_future(foo([].to_vec(), &0));
    |                                     ^^^^^^^^^^^ help: use: `[]`

 error: aborting due to 80 previous errors
	error: redundant clone
	--> $DIR/unnecessary_to_owned.rs:154:64
	\|
	LL \| require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
	\| ^^^^^^^^^^^ help: remove this
	\|
	note: this value is dropped without further use
	--> $DIR/unnecessary_to_owned.rs:154:20
	\|
	LL \| require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	= note: `-D clippy::redundant-clone` implied by `-D warnings`
	= help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`

	error: redundant clone
	--> $DIR/unnecessary_to_owned.rs:155:40
	\|
	LL \| require_os_str(&OsString::from("x").to_os_string());
	\| ^^^^^^^^^^^^^^^ help: remove this
	\|
	note: this value is dropped without further use
	--> $DIR/unnecessary_to_owned.rs:155:21
	\|
	LL \| require_os_str(&OsString::from("x").to_os_string());
	\| ^^^^^^^^^^^^^^^^^^^

	error: redundant clone
	--> $DIR/unnecessary_to_owned.rs:156:48
	\|
	LL \| require_path(&std::path::PathBuf::from("x").to_path_buf());
	\| ^^^^^^^^^^^^^^ help: remove this
	\|
	note: this value is dropped without further use
	--> $DIR/unnecessary_to_owned.rs:156:19
	\|
	LL \| require_path(&std::path::PathBuf::from("x").to_path_buf());
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

	error: redundant clone
	--> $DIR/unnecessary_to_owned.rs:157:35
	\|
	LL \| require_str(&String::from("x").to_string());
	\| ^^^^^^^^^^^^ help: remove this
	\|
	note: this value is dropped without further use
	--> $DIR/unnecessary_to_owned.rs:157:18
	\|
	LL \| require_str(&String::from("x").to_string());
	\| ^^^^^^^^^^^^^^^^^

	error: redundant clone
	--> $DIR/unnecessary_to_owned.rs:158:39
	\|
	LL \| require_slice(&[String::from("x")].to_owned());
	\| ^^^^^^^^^^^ help: remove this
	\|
	note: this value is dropped without further use
	--> $DIR/unnecessary_to_owned.rs:158:20
	\|
	LL \| require_slice(&[String::from("x")].to_owned());
	\| ^^^^^^^^^^^^^^^^^^^

	error: unnecessary use of `into_owned`
	--> $DIR/unnecessary_to_owned.rs:63:36
	\|
	LL \| require_c_str(&Cow::from(c_str).into_owned());
	\| ^^^^^^^^^^^^^ help: remove this
	\|
	= note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
	= help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:64:19
	\|
	LL \| require_c_str(&c_str.to_owned());
	\| ^^^^^^^^^^^^^^^^^ help: use: `c_str`

	error: unnecessary use of `to_os_string`
	--> $DIR/unnecessary_to_owned.rs:66:20
	\|
	LL \| require_os_str(&os_str.to_os_string());
	\| ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`

	error: unnecessary use of `into_owned`
	--> $DIR/unnecessary_to_owned.rs:67:38
	\|
	LL \| require_os_str(&Cow::from(os_str).into_owned());
	\| ^^^^^^^^^^^^^ help: remove this

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:68:20
	\|
	LL \| require_os_str(&os_str.to_owned());
	\| ^^^^^^^^^^^^^^^^^^ help: use: `os_str`

	error: unnecessary use of `to_path_buf`
	--> $DIR/unnecessary_to_owned.rs:70:18
	\|
	LL \| require_path(&path.to_path_buf());
	\| ^^^^^^^^^^^^^^^^^^^ help: use: `path`

	error: unnecessary use of `into_owned`
	--> $DIR/unnecessary_to_owned.rs:71:34
	\|
	LL \| require_path(&Cow::from(path).into_owned());
	\| ^^^^^^^^^^^^^ help: remove this

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:72:18
	\|
	LL \| require_path(&path.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `path`

	error: unnecessary use of `to_string`
	--> $DIR/unnecessary_to_owned.rs:74:17
	\|
	LL \| require_str(&s.to_string());
	\| ^^^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `into_owned`
	--> $DIR/unnecessary_to_owned.rs:75:30
	\|
	LL \| require_str(&Cow::from(s).into_owned());
	\| ^^^^^^^^^^^^^ help: remove this

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:76:17
	\|
	LL \| require_str(&s.to_owned());
	\| ^^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_string`
	--> $DIR/unnecessary_to_owned.rs:77:17
	\|
	LL \| require_str(&x_ref.to_string());
	\| ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:79:19
	\|
	LL \| require_slice(&slice.to_vec());
	\| ^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `into_owned`
	--> $DIR/unnecessary_to_owned.rs:80:36
	\|
	LL \| require_slice(&Cow::from(slice).into_owned());
	\| ^^^^^^^^^^^^^ help: remove this

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:81:19
	\|
	LL \| require_slice(&array.to_owned());
	\| ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:82:19
	\|
	LL \| require_slice(&array_ref.to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:83:19
	\|
	LL \| require_slice(&slice.to_owned());
	\| ^^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `into_owned`
	--> $DIR/unnecessary_to_owned.rs:86:42
	\|
	LL \| require_x(&Cow::<X>::Owned(x.clone()).into_owned());
	\| ^^^^^^^^^^^^^ help: remove this

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:89:25
	\|
	LL \| require_deref_c_str(c_str.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `c_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:90:26
	\|
	LL \| require_deref_os_str(os_str.to_owned());
	\| ^^^^^^^^^^^^^^^^^ help: use: `os_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:91:24
	\|
	LL \| require_deref_path(path.to_owned());
	\| ^^^^^^^^^^^^^^^ help: use: `path`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:92:23
	\|
	LL \| require_deref_str(s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:93:25
	\|
	LL \| require_deref_slice(slice.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:95:30
	\|
	LL \| require_impl_deref_c_str(c_str.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `c_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:96:31
	\|
	LL \| require_impl_deref_os_str(os_str.to_owned());
	\| ^^^^^^^^^^^^^^^^^ help: use: `os_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:97:29
	\|
	LL \| require_impl_deref_path(path.to_owned());
	\| ^^^^^^^^^^^^^^^ help: use: `path`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:98:28
	\|
	LL \| require_impl_deref_str(s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:99:30
	\|
	LL \| require_impl_deref_slice(slice.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:101:29
	\|
	LL \| require_deref_str_slice(s.to_owned(), slice.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:101:43
	\|
	LL \| require_deref_str_slice(s.to_owned(), slice.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:102:29
	\|
	LL \| require_deref_slice_str(slice.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:102:47
	\|
	LL \| require_deref_slice_str(slice.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:104:26
	\|
	LL \| require_as_ref_c_str(c_str.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `c_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:105:27
	\|
	LL \| require_as_ref_os_str(os_str.to_owned());
	\| ^^^^^^^^^^^^^^^^^ help: use: `os_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:106:25
	\|
	LL \| require_as_ref_path(path.to_owned());
	\| ^^^^^^^^^^^^^^^ help: use: `path`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:107:24
	\|
	LL \| require_as_ref_str(s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:108:24
	\|
	LL \| require_as_ref_str(x.to_owned());
	\| ^^^^^^^^^^^^ help: use: `&x`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:109:26
	\|
	LL \| require_as_ref_slice(array.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `array`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:110:26
	\|
	LL \| require_as_ref_slice(array_ref.to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:111:26
	\|
	LL \| require_as_ref_slice(slice.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:113:31
	\|
	LL \| require_impl_as_ref_c_str(c_str.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `c_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:114:32
	\|
	LL \| require_impl_as_ref_os_str(os_str.to_owned());
	\| ^^^^^^^^^^^^^^^^^ help: use: `os_str`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:115:30
	\|
	LL \| require_impl_as_ref_path(path.to_owned());
	\| ^^^^^^^^^^^^^^^ help: use: `path`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:116:29
	\|
	LL \| require_impl_as_ref_str(s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:117:29
	\|
	LL \| require_impl_as_ref_str(x.to_owned());
	\| ^^^^^^^^^^^^ help: use: `&x`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:118:31
	\|
	LL \| require_impl_as_ref_slice(array.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `array`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:119:31
	\|
	LL \| require_impl_as_ref_slice(array_ref.to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:120:31
	\|
	LL \| require_impl_as_ref_slice(slice.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:122:30
	\|
	LL \| require_as_ref_str_slice(s.to_owned(), array.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:122:44
	\|
	LL \| require_as_ref_str_slice(s.to_owned(), array.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `array`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:123:30
	\|
	LL \| require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:123:44
	\|
	LL \| require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:124:30
	\|
	LL \| require_as_ref_str_slice(s.to_owned(), slice.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:124:44
	\|
	LL \| require_as_ref_str_slice(s.to_owned(), slice.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:125:30
	\|
	LL \| require_as_ref_slice_str(array.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `array`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:125:48
	\|
	LL \| require_as_ref_slice_str(array.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:126:30
	\|
	LL \| require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:126:52
	\|
	LL \| require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:127:30
	\|
	LL \| require_as_ref_slice_str(slice.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^^^^^ help: use: `slice`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:127:48
	\|
	LL \| require_as_ref_slice_str(slice.to_owned(), s.to_owned());
	\| ^^^^^^^^^^^^ help: use: `s`

	error: unnecessary use of `to_string`
	--> $DIR/unnecessary_to_owned.rs:129:20
	\|
	LL \| let _ = x.join(&x_ref.to_string());
	\| ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:131:13
	\|
	LL \| let _ = slice.to_vec().into_iter();
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:132:13
	\|
	LL \| let _ = slice.to_owned().into_iter();
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:133:13
	\|
	LL \| let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:134:13
	\|
	LL \| let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:136:13
	\|
	LL \| let _ = IntoIterator::into_iter(slice.to_vec());
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:137:13
	\|
	LL \| let _ = IntoIterator::into_iter(slice.to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:138:13
	\|
	LL \| let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

	error: unnecessary use of `to_owned`
	--> $DIR/unnecessary_to_owned.rs:139:13
	\|
	LL \| let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:201:14
	\|
	LL \| for t in file_types.to_vec() {
	\| ^^^^^^^^^^^^^^^^^^^
	\|
	help: use
	\|
	LL \| for t in file_types {
	\| ~~~~~~~~~~
	help: remove this `&`
	\|
	LL - let path = match get_file_path(&t) {
	LL + let path = match get_file_path(t) {
	\|

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:224:14
	\|
	LL \| let _ = &["x"][..].to_vec().into_iter();
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().cloned()`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:229:14
	\|
	LL \| let _ = &["x"][..].to_vec().into_iter();
	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().copied()`

	error: unnecessary use of `to_string`
	--> $DIR/unnecessary_to_owned.rs:276:24
	\|
	LL \| Box::new(build(y.to_string()))
	\| ^^^^^^^^^^^^^ help: use: `y`

	error: unnecessary use of `to_string`
	--> $DIR/unnecessary_to_owned.rs:384:12
	\|
	LL \| id("abc".to_string())
	\| ^^^^^^^^^^^^^^^^^ help: use: `"abc"`

	error: unnecessary use of `to_vec`
	--> $DIR/unnecessary_to_owned.rs:527:37
	\|
	LL \| IntoFuture::into_future(foo([].to_vec(), &0));
	\| ^^^^^^^^^^^ help: use: `[]`

	error: aborting due to 80 previous errors