rust-clippy/tests/ui/redundant_clone.stderr

error: redundant clone
  --> $DIR/redundant_clone.rs:8:42
   |
LL |     let _s = ["lorem", "ipsum"].join(" ").to_string();
   |                                          ^^^^^^^^^^^^ help: remove this
   |
   = note: `-D clippy::redundant-clone` implied by `-D warnings`
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:8:14
   |
LL |     let _s = ["lorem", "ipsum"].join(" ").to_string();
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: redundant clone
  --> $DIR/redundant_clone.rs:11:15
   |
LL |     let _s = s.clone();
   |               ^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:11:14
   |
LL |     let _s = s.clone();
   |              ^

error: redundant clone
  --> $DIR/redundant_clone.rs:14:15
   |
LL |     let _s = s.to_string();
   |               ^^^^^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:14:14
   |
LL |     let _s = s.to_string();
   |              ^

error: redundant clone
  --> $DIR/redundant_clone.rs:17:15
   |
LL |     let _s = s.to_owned();
   |               ^^^^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:17:14
   |
LL |     let _s = s.to_owned();
   |              ^

error: redundant clone
  --> $DIR/redundant_clone.rs:19:42
   |
LL |     let _s = Path::new("/a/b/").join("c").to_owned();
   |                                          ^^^^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:19:14
   |
LL |     let _s = Path::new("/a/b/").join("c").to_owned();
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: redundant clone
  --> $DIR/redundant_clone.rs:21:42
   |
LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
   |                                          ^^^^^^^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:21:14
   |
LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: redundant clone
  --> $DIR/redundant_clone.rs:23:29
   |
LL |     let _s = OsString::new().to_owned();
   |                             ^^^^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:23:14
   |
LL |     let _s = OsString::new().to_owned();
   |              ^^^^^^^^^^^^^^^

error: redundant clone
  --> $DIR/redundant_clone.rs:25:29
   |
LL |     let _s = OsString::new().to_os_string();
   |                             ^^^^^^^^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:25:14
   |
LL |     let _s = OsString::new().to_os_string();
   |              ^^^^^^^^^^^^^^^

error: redundant clone
  --> $DIR/redundant_clone.rs:32:19
   |
LL |     let _t = tup.0.clone();
   |                   ^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:32:14
   |
LL |     let _t = tup.0.clone();
   |              ^^^^^

error: redundant clone
  --> $DIR/redundant_clone.rs:62:22
   |
LL |         (a.clone(), a.clone())
   |                      ^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:62:21
   |
LL |         (a.clone(), a.clone())
   |                     ^

error: redundant clone
  --> $DIR/redundant_clone.rs:122:15
   |
LL |     let _s = s.clone();
   |               ^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:122:14
   |
LL |     let _s = s.clone();
   |              ^

error: redundant clone
  --> $DIR/redundant_clone.rs:123:15
   |
LL |     let _t = t.clone();
   |               ^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:123:14
   |
LL |     let _t = t.clone();
   |              ^

error: redundant clone
  --> $DIR/redundant_clone.rs:133:19
   |
LL |         let _f = f.clone();
   |                   ^^^^^^^^ help: remove this
   |
note: this value is dropped without further use
  --> $DIR/redundant_clone.rs:133:18
   |
LL |         let _f = f.clone();
   |                  ^

error: redundant clone
  --> $DIR/redundant_clone.rs:145:14
   |
LL |     let y = x.clone().join("matthias");
   |              ^^^^^^^^ help: remove this
   |
note: cloned value is neither consumed nor mutated
  --> $DIR/redundant_clone.rs:145:13
   |
LL |     let y = x.clone().join("matthias");
   |             ^^^^^^^^^

error: aborting due to 14 previous errors
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`error: redundant clone`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:8:42`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = ["lorem", "ipsum"].join(" ").to_string();`
			`\| ^^^^^^^^^^^^ help: remove this`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
			= note: `-D clippy::redundant-clone` implied by `-D warnings`
			`note: this value is dropped without further use`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:8:14`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = ["lorem", "ipsum"].join(" ").to_string();`
			`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00
			`error: redundant clone`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:11:15`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.clone();`
			`\| ^^^^^^^^ help: remove this`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
			`note: this value is dropped without further use`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:11:14`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.clone();`
			`\| ^`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00
			`error: redundant clone`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:14:15`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.to_string();`
			`\| ^^^^^^^^^^^^ help: remove this`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
			`note: this value is dropped without further use`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:14:14`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.to_string();`
			`\| ^`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00
			`error: redundant clone`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:17:15`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.to_owned();`
			`\| ^^^^^^^^^^^ help: remove this`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
			`note: this value is dropped without further use`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:17:14`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.to_owned();`
			`\| ^`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00
			`error: redundant clone`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:19:42`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = Path::new("/a/b/").join("c").to_owned();`
			`\| ^^^^^^^^^^^ help: remove this`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
			`note: this value is dropped without further use`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:19:14`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = Path::new("/a/b/").join("c").to_owned();`
			`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00
Fix `redundant_clone` 2020-01-08 04:59:58 +00:00			`error: redundant clone`
			`--> $DIR/redundant_clone.rs:21:42`
			`\|`
			`LL \| let _s = Path::new("/a/b/").join("c").to_path_buf();`
			`\| ^^^^^^^^^^^^^^ help: remove this`
			`\|`
			`note: this value is dropped without further use`
			`--> $DIR/redundant_clone.rs:21:14`
			`\|`
			`LL \| let _s = Path::new("/a/b/").join("c").to_path_buf();`
			`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`

Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`error: redundant clone`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:23:29`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = OsString::new().to_owned();`
			`\| ^^^^^^^^^^^ help: remove this`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
			`note: this value is dropped without further use`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:23:14`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = OsString::new().to_owned();`
			`\| ^^^^^^^^^^^^^^^`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00
Fix `redundant_clone` 2020-01-08 04:59:58 +00:00			`error: redundant clone`
			`--> $DIR/redundant_clone.rs:25:29`
			`\|`
			`LL \| let _s = OsString::new().to_os_string();`
			`\| ^^^^^^^^^^^^^^^ help: remove this`
			`\|`
			`note: this value is dropped without further use`
			`--> $DIR/redundant_clone.rs:25:14`
			`\|`
			`LL \| let _s = OsString::new().to_os_string();`
			`\| ^^^^^^^^^^^^^^^`

Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`error: redundant clone`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:32:19`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _t = tup.0.clone();`
			`\| ^^^^^^^^ help: remove this`
Lint redundant clone of projection 2018-12-09 11:19:21 +00:00			`\|`
			`note: this value is dropped without further use`
Rustup to rustc 1.41.0-nightly (d1da8023d 2019-11-19) 2019-11-19 08:32:35 +00:00			`--> $DIR/redundant_clone.rs:32:14`
Lint redundant clone of projection 2018-12-09 11:19:21 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _t = tup.0.clone();`
			`\| ^^^^^`
Lint redundant clone of projection 2018-12-09 11:19:21 +00:00
			`error: redundant clone`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:62:22`
Lint redundant clone of projection 2018-12-09 11:19:21 +00:00			`\|`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`LL \| (a.clone(), a.clone())`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\| ^^^^^^^^ help: remove this`
			`\|`
			`note: this value is dropped without further use`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:62:21`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\|`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`LL \| (a.clone(), a.clone())`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00			`\| ^`

Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`error: redundant clone`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:122:15`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.clone();`
			`\| ^^^^^^^^ help: remove this`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
			`note: this value is dropped without further use`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:122:14`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _s = s.clone();`
			`\| ^`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00
			`error: redundant clone`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:123:15`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _t = t.clone();`
			`\| ^^^^^^^^ help: remove this`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
			`note: this value is dropped without further use`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:123:14`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
Add run-rustfix 2019-09-10 02:56:34 +00:00			`LL \| let _t = t.clone();`
			`\| ^`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00
			`error: redundant clone`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:133:19`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
			`LL \| let _f = f.clone();`
			`\| ^^^^^^^^ help: remove this`
			`\|`
			`note: this value is dropped without further use`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:133:18`
Fix false-positive of redundant_clone and move to clippy::perf 2019-09-16 15:50:15 +00:00			`\|`
			`LL \| let _f = f.clone();`
			`\| ^`

Extend `redundant_clone` to the case that cloned value is not consumed 2020-03-12 15:31:09 +00:00			`error: redundant clone`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:145:14`
Extend `redundant_clone` to the case that cloned value is not consumed 2020-03-12 15:31:09 +00:00			`\|`
			`LL \| let y = x.clone().join("matthias");`
			`\| ^^^^^^^^ help: remove this`
			`\|`
Check for mutation 2020-03-12 16:25:18 +00:00			`note: cloned value is neither consumed nor mutated`
Ignore not really redundant clones of ManuallyDrop "Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of invoking the clone, without running the drop implementation of the inner type. In other words, they aren't really redundant. For example, futures-rs crate: ```rust #[allow(clippy::redundant_clone)] // The clone here isn't actually redundant. unsafe fn increase_refcount<T: ArcWake>(data: const ()) { // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as const T)); // Now increase refcount, but don't drop new refcount either let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); } ``` Ignore redundant clone lint for ManuallyDrop. 2020-07-20 00:00:00 +00:00			`--> $DIR/redundant_clone.rs:145:13`
Extend `redundant_clone` to the case that cloned value is not consumed 2020-03-12 15:31:09 +00:00			`\|`
			`LL \| let y = x.clone().join("matthias");`
			`\| ^^^^^^^^^`

			`error: aborting due to 14 previous errors`
Add redundant_clone lint 2018-10-23 07:01:45 +00:00