rust-clippy/tests/ui/explicit_deref_methods.rs

131 lines
2.6 KiB
Rust
Raw Normal View History

#![warn(clippy::explicit_deref_methods)]
#![allow(unused_variables, unused_must_use)]
#![allow(
clippy::borrow_deref_ref,
suspicious_double_ref_op,
2023-05-25 05:21:44 +00:00
noop_method_call,
clippy::explicit_auto_deref,
clippy::needless_borrow,
clippy::no_effect,
clippy::uninlined_format_args,
clippy::unnecessary_literal_unwrap
)]
2018-10-03 16:53:39 +00:00
use std::ops::{Deref, DerefMut};
2020-01-26 18:48:30 +00:00
fn concat(deref_str: &str) -> String {
format!("{}bar", deref_str)
}
fn just_return(deref_str: &str) -> &str {
deref_str
}
struct CustomVec(Vec<u8>);
impl Deref for CustomVec {
type Target = Vec<u8>;
fn deref(&self) -> &Vec<u8> {
&self.0
}
}
struct Aaa;
impl Deref for Aaa {
type Target = ();
fn deref(&self) -> &Self::Target {
todo!();
}
}
impl DerefMut for Aaa {
fn deref_mut(&mut self) -> &mut Self::Target {
todo!();
}
}
2018-10-03 16:53:39 +00:00
fn main() {
let a: &mut String = &mut String::from("foo");
// these should require linting
2020-01-26 18:48:30 +00:00
2020-01-23 15:28:01 +00:00
let b: &str = a.deref();
2018-10-03 16:53:39 +00:00
2020-01-23 15:28:01 +00:00
let b: &mut str = a.deref_mut();
2018-10-03 16:53:39 +00:00
2020-01-26 18:48:30 +00:00
// both derefs should get linted here
let b: String = format!("{}, {}", a.deref(), a.deref());
println!("{}", a.deref());
#[allow(clippy::match_single_binding)]
match a.deref() {
_ => (),
}
let b: String = concat(a.deref());
let b = just_return(a).deref();
let b: String = concat(just_return(a).deref());
let b: &str = a.deref().deref();
let opt_a = Some(a.clone());
let b = opt_a.unwrap().deref();
// make sure `Aaa::deref` instead of `aaa.deref()` is not linted, as well as fully qualified
// syntax
Aaa::deref(&Aaa);
Aaa::deref_mut(&mut Aaa);
<Aaa as Deref>::deref(&Aaa);
<Aaa as DerefMut>::deref_mut(&mut Aaa);
let mut aaa = Aaa;
Aaa::deref(&aaa);
Aaa::deref_mut(&mut aaa);
// following should not require linting
let cv = CustomVec(vec![0, 42]);
let c = cv.deref()[0];
let b: &str = &*a.deref();
2020-01-23 15:28:01 +00:00
let b: String = a.deref().clone();
2018-10-03 16:53:39 +00:00
2020-01-23 15:28:01 +00:00
let b: usize = a.deref_mut().len();
2018-10-03 16:53:39 +00:00
2020-01-23 15:28:01 +00:00
let b: &usize = &a.deref().len();
let b: &str = &*a;
let b: &mut str = &mut *a;
2018-10-03 16:53:39 +00:00
2020-01-23 15:28:01 +00:00
macro_rules! expr_deref {
($body:expr) => {
$body.deref()
};
2018-10-03 16:53:39 +00:00
}
2020-01-23 15:28:01 +00:00
let b: &str = expr_deref!(a);
2020-01-26 18:48:30 +00:00
let b: &str = expr_deref!(a.deref());
// The struct does not implement Deref trait
#[derive(Copy, Clone)]
struct NoLint(u32);
impl NoLint {
pub fn deref(self) -> u32 {
self.0
}
pub fn deref_mut(self) -> u32 {
self.0
}
}
let no_lint = NoLint(42);
let b = no_lint.deref();
let b = no_lint.deref_mut();
2018-10-03 16:53:39 +00:00
}