src/tools/clippy/tests/ui/unnecessary_to_owned.rs

   1 // run-rustfix
   2
   3 #![allow(clippy::ptr_arg)]
   4 #![warn(clippy::unnecessary_to_owned)]
   5
   6 use std::borrow::Cow;
   7 use std::ffi::{CStr, CString, OsStr, OsString};
   8 use std::ops::Deref;
   9
  10 #[derive(Clone)]
  11 struct X(String);
  12
  13 impl Deref for X {
  14     type Target = [u8];
  15     fn deref(&self) -> &[u8] {
  16         self.0.as_bytes()
  17     }
  18 }
  19
  20 impl AsRef<str> for X {
  21     fn as_ref(&self) -> &str {
  22         self.0.as_str()
  23     }
  24 }
  25
  26 impl ToString for X {
  27     fn to_string(&self) -> String {
  28         self.0.to_string()
  29     }
  30 }
  31
  32 impl X {
  33     fn join(&self, other: impl AsRef<str>) -> Self {
  34         let mut s = self.0.clone();
  35         s.push_str(other.as_ref());
  36         Self(s)
  37     }
  38 }
  39
  40 #[allow(dead_code)]
  41 #[derive(Clone)]
  42 enum FileType {
  43     Account,
  44     PrivateKey,
  45     Certificate,
  46 }
  47
  48 fn main() {
  49     let c_str = CStr::from_bytes_with_nul(&[0]).unwrap();
  50     let os_str = OsStr::new("x");
  51     let path = std::path::Path::new("x");
  52     let s = "x";
  53     let array = ["x"];
  54     let array_ref = &["x"];
  55     let slice = &["x"][..];
  56     let x = X(String::from("x"));
  57     let x_ref = &x;
  58
  59     require_c_str(&Cow::from(c_str).into_owned());
  60     require_c_str(&c_str.to_owned());
  61
  62     require_os_str(&os_str.to_os_string());
  63     require_os_str(&Cow::from(os_str).into_owned());
  64     require_os_str(&os_str.to_owned());
  65
  66     require_path(&path.to_path_buf());
  67     require_path(&Cow::from(path).into_owned());
  68     require_path(&path.to_owned());
  69
  70     require_str(&s.to_string());
  71     require_str(&Cow::from(s).into_owned());
  72     require_str(&s.to_owned());
  73     require_str(&x_ref.to_string());
  74
  75     require_slice(&slice.to_vec());
  76     require_slice(&Cow::from(slice).into_owned());
  77     require_slice(&array.to_owned());
  78     require_slice(&array_ref.to_owned());
  79     require_slice(&slice.to_owned());
  80     require_slice(&x_ref.to_owned());
  81
  82     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
  83     require_x(&x_ref.to_owned());
  84
  85     require_deref_c_str(c_str.to_owned());
  86     require_deref_os_str(os_str.to_owned());
  87     require_deref_path(path.to_owned());
  88     require_deref_str(s.to_owned());
  89     require_deref_slice(slice.to_owned());
  90
  91     require_impl_deref_c_str(c_str.to_owned());
  92     require_impl_deref_os_str(os_str.to_owned());
  93     require_impl_deref_path(path.to_owned());
  94     require_impl_deref_str(s.to_owned());
  95     require_impl_deref_slice(slice.to_owned());
  96
  97     require_deref_str_slice(s.to_owned(), slice.to_owned());
  98     require_deref_slice_str(slice.to_owned(), s.to_owned());
  99
 100     require_as_ref_c_str(c_str.to_owned());
 101     require_as_ref_os_str(os_str.to_owned());
 102     require_as_ref_path(path.to_owned());
 103     require_as_ref_str(s.to_owned());
 104     require_as_ref_str(x.to_owned());
 105     require_as_ref_slice(array.to_owned());
 106     require_as_ref_slice(array_ref.to_owned());
 107     require_as_ref_slice(slice.to_owned());
 108
 109     require_impl_as_ref_c_str(c_str.to_owned());
 110     require_impl_as_ref_os_str(os_str.to_owned());
 111     require_impl_as_ref_path(path.to_owned());
 112     require_impl_as_ref_str(s.to_owned());
 113     require_impl_as_ref_str(x.to_owned());
 114     require_impl_as_ref_slice(array.to_owned());
 115     require_impl_as_ref_slice(array_ref.to_owned());
 116     require_impl_as_ref_slice(slice.to_owned());
 117
 118     require_as_ref_str_slice(s.to_owned(), array.to_owned());
 119     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
 120     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
 121     require_as_ref_slice_str(array.to_owned(), s.to_owned());
 122     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
 123     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
 124
 125     let _ = x.join(&x_ref.to_string());
 126
 127     let _ = slice.to_vec().into_iter();
 128     let _ = slice.to_owned().into_iter();
 129     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
 130     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
 131
 132     let _ = IntoIterator::into_iter(slice.to_vec());
 133     let _ = IntoIterator::into_iter(slice.to_owned());
 134     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
 135     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
 136
 137     let _ = check_files(&[FileType::Account]);
 138
 139     // negative tests
 140     require_string(&s.to_string());
 141     require_string(&Cow::from(s).into_owned());
 142     require_string(&s.to_owned());
 143     require_string(&x_ref.to_string());
 144
 145     // `X` isn't copy.
 146     require_slice(&x.to_owned());
 147     require_deref_slice(x.to_owned());
 148
 149     // The following should be flagged by `redundant_clone`, but not by this lint.
 150     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
 151     require_os_str(&OsString::from("x").to_os_string());
 152     require_path(&std::path::PathBuf::from("x").to_path_buf());
 153     require_str(&String::from("x").to_string());
 154 }
 155
 156 fn require_c_str(_: &CStr) {}
 157 fn require_os_str(_: &OsStr) {}
 158 fn require_path(_: &std::path::Path) {}
 159 fn require_str(_: &str) {}
 160 fn require_slice<T>(_: &[T]) {}
 161 fn require_x(_: &X) {}
 162
 163 fn require_deref_c_str<T: Deref<Target = CStr>>(_: T) {}
 164 fn require_deref_os_str<T: Deref<Target = OsStr>>(_: T) {}
 165 fn require_deref_path<T: Deref<Target = std::path::Path>>(_: T) {}
 166 fn require_deref_str<T: Deref<Target = str>>(_: T) {}
 167 fn require_deref_slice<T, U: Deref<Target = [T]>>(_: U) {}
 168
 169 fn require_impl_deref_c_str(_: impl Deref<Target = CStr>) {}
 170 fn require_impl_deref_os_str(_: impl Deref<Target = OsStr>) {}
 171 fn require_impl_deref_path(_: impl Deref<Target = std::path::Path>) {}
 172 fn require_impl_deref_str(_: impl Deref<Target = str>) {}
 173 fn require_impl_deref_slice<T>(_: impl Deref<Target = [T]>) {}
 174
 175 fn require_deref_str_slice<T: Deref<Target = str>, U, V: Deref<Target = [U]>>(_: T, _: V) {}
 176 fn require_deref_slice_str<T, U: Deref<Target = [T]>, V: Deref<Target = str>>(_: U, _: V) {}
 177
 178 fn require_as_ref_c_str<T: AsRef<CStr>>(_: T) {}
 179 fn require_as_ref_os_str<T: AsRef<OsStr>>(_: T) {}
 180 fn require_as_ref_path<T: AsRef<std::path::Path>>(_: T) {}
 181 fn require_as_ref_str<T: AsRef<str>>(_: T) {}
 182 fn require_as_ref_slice<T, U: AsRef<[T]>>(_: U) {}
 183
 184 fn require_impl_as_ref_c_str(_: impl AsRef<CStr>) {}
 185 fn require_impl_as_ref_os_str(_: impl AsRef<OsStr>) {}
 186 fn require_impl_as_ref_path(_: impl AsRef<std::path::Path>) {}
 187 fn require_impl_as_ref_str(_: impl AsRef<str>) {}
 188 fn require_impl_as_ref_slice<T>(_: impl AsRef<[T]>) {}
 189
 190 fn require_as_ref_str_slice<T: AsRef<str>, U, V: AsRef<[U]>>(_: T, _: V) {}
 191 fn require_as_ref_slice_str<T, U: AsRef<[T]>, V: AsRef<str>>(_: U, _: V) {}
 192
 193 // `check_files` is based on:
 194 // https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
 195 fn check_files(file_types: &[FileType]) -> bool {
 196     for t in file_types.to_vec() {
 197         let path = match get_file_path(&t) {
 198             Ok(p) => p,
 199             Err(_) => {
 200                 return false;
 201             },
 202         };
 203         if !path.is_file() {
 204             return false;
 205         }
 206     }
 207     true
 208 }
 209
 210 fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::Error> {
 211     Ok(std::path::PathBuf::new())
 212 }
 213
 214 fn require_string(_: &String) {}
 215
 216 // https://github.com/rust-lang/rust-clippy/issues/8507
 217 mod issue_8507 {
 218     #![allow(dead_code)]
 219
 220     struct Opaque<P>(P);
 221
 222     pub trait Abstracted {}
 223
 224     impl<P> Abstracted for Opaque<P> {}
 225
 226     fn build<P>(p: P) -> Opaque<P>
 227     where
 228         P: AsRef<str>,
 229     {
 230         Opaque(p)
 231     }
 232
 233     // Should not lint.
 234     fn test_str(s: &str) -> Box<dyn Abstracted> {
 235         Box::new(build(s.to_string()))
 236     }
 237
 238     // Should not lint.
 239     fn test_x(x: super::X) -> Box<dyn Abstracted> {
 240         Box::new(build(x))
 241     }
 242
 243     #[derive(Clone, Copy)]
 244     struct Y(&'static str);
 245
 246     impl AsRef<str> for Y {
 247         fn as_ref(&self) -> &str {
 248             self.0
 249         }
 250     }
 251
 252     impl ToString for Y {
 253         fn to_string(&self) -> String {
 254             self.0.to_string()
 255         }
 256     }
 257
 258     // Should lint because Y is copy.
 259     fn test_y(y: Y) -> Box<dyn Abstracted> {
 260         Box::new(build(y.to_string()))
 261     }
 262 }