rust-clippy/tests/ui/unnecessary_clone.rs

111 lines
2.1 KiB
Rust
Raw Normal View History

// does not test any rustfixable lints
2018-07-28 15:34:52 +00:00
#![warn(clippy::clone_on_ref_ptr)]
2020-11-17 16:01:22 +00:00
#![allow(unused, clippy::redundant_clone, clippy::unnecessary_wraps)]
2017-10-10 04:07:12 +00:00
use std::cell::RefCell;
2017-10-10 04:07:12 +00:00
use std::rc::{self, Rc};
use std::sync::{self, Arc};
trait SomeTrait {}
struct SomeImpl;
impl SomeTrait for SomeImpl {}
2017-10-10 04:07:12 +00:00
fn main() {}
fn clone_on_ref_ptr() {
let rc = Rc::new(true);
let arc = Arc::new(true);
let rcweak = Rc::downgrade(&rc);
let arc_weak = Arc::downgrade(&arc);
rc.clone();
Rc::clone(&rc);
arc.clone();
Arc::clone(&arc);
rcweak.clone();
rc::Weak::clone(&rcweak);
arc_weak.clone();
sync::Weak::clone(&arc_weak);
let x = Arc::new(SomeImpl);
let _: Arc<dyn SomeTrait> = x.clone();
2017-10-10 04:07:12 +00:00
}
fn clone_on_copy_generic<T: Copy>(t: T) {
t.clone();
Some(t).clone();
}
fn clone_on_double_ref() {
let x = vec![1];
let y = &&x;
let z: &Vec<_> = y.clone();
2018-12-09 22:26:16 +00:00
println!("{:p} {:p}", *y, z);
2017-10-10 04:07:12 +00:00
}
2018-10-19 18:51:25 +00:00
mod many_derefs {
struct A;
struct B;
struct C;
struct D;
#[derive(Copy, Clone)]
struct E;
macro_rules! impl_deref {
($src:ident, $dst:ident) => {
impl std::ops::Deref for $src {
type Target = $dst;
2018-12-09 22:26:16 +00:00
fn deref(&self) -> &Self::Target {
&$dst
}
2018-10-19 18:51:25 +00:00
}
2018-12-09 22:26:16 +00:00
};
2018-10-19 18:51:25 +00:00
}
impl_deref!(A, B);
impl_deref!(B, C);
impl_deref!(C, D);
impl std::ops::Deref for D {
type Target = &'static E;
2018-12-09 22:26:16 +00:00
fn deref(&self) -> &Self::Target {
&&E
}
2018-10-19 18:51:25 +00:00
}
fn go1() {
let a = A;
let _: E = a.clone();
let _: E = *****a;
}
fn check(mut encoded: &[u8]) {
let _ = &mut encoded.clone();
let _ = &encoded.clone();
}
2018-10-19 18:51:25 +00:00
}
mod issue2076 {
use std::rc::Rc;
macro_rules! try_opt {
($expr: expr) => {
match $expr {
Some(value) => value,
None => return None,
}
};
}
fn func() -> Option<Rc<u8>> {
let rc = Rc::new(42);
Some(try_opt!(Some(rc)).clone())
}
}