tests/ui/methods.rs

   1 // aux-build:option_helpers.rs
   2
   3 #![warn(clippy::all, clippy::pedantic, clippy::option_unwrap_used)]
   4 #![allow(
   5     clippy::blacklisted_name,
   6     unused,
   7     clippy::print_stdout,
   8     clippy::non_ascii_literal,
   9     clippy::new_without_default,
  10     clippy::missing_docs_in_private_items,
  11     clippy::needless_pass_by_value,
  12     clippy::default_trait_access,
  13     clippy::use_self,
  14     clippy::new_ret_no_self,
  15     clippy::useless_format
  16 )]
  17
  18 #[macro_use]
  19 extern crate option_helpers;
  20
  21 use std::collections::BTreeMap;
  22 use std::collections::HashMap;
  23 use std::collections::HashSet;
  24 use std::collections::VecDeque;
  25 use std::iter::FromIterator;
  26 use std::ops::Mul;
  27 use std::rc::{self, Rc};
  28 use std::sync::{self, Arc};
  29
  30 use option_helpers::IteratorFalsePositives;
  31
  32 pub struct T;
  33
  34 impl T {
  35     pub fn add(self, other: T) -> T {
  36         self
  37     }
  38
  39     // no error, not public interface
  40     pub(crate) fn drop(&mut self) {}
  41
  42     // no error, private function
  43     fn neg(self) -> Self {
  44         self
  45     }
  46
  47     // no error, private function
  48     fn eq(&self, other: T) -> bool {
  49         true
  50     }
  51
  52     // No error; self is a ref.
  53     fn sub(&self, other: T) -> &T {
  54         self
  55     }
  56
  57     // No error; different number of arguments.
  58     fn div(self) -> T {
  59         self
  60     }
  61
  62     // No error; wrong return type.
  63     fn rem(self, other: T) {}
  64
  65     // Fine
  66     fn into_u32(self) -> u32 {
  67         0
  68     }
  69
  70     fn into_u16(&self) -> u16 {
  71         0
  72     }
  73
  74     fn to_something(self) -> u32 {
  75         0
  76     }
  77
  78     fn new(self) -> Self {
  79         unimplemented!();
  80     }
  81 }
  82
  83 struct Lt<'a> {
  84     foo: &'a u32,
  85 }
  86
  87 impl<'a> Lt<'a> {
  88     // The lifetime is different, but that’s irrelevant; see issue #734.
  89     #[allow(clippy::needless_lifetimes)]
  90     pub fn new<'b>(s: &'b str) -> Lt<'b> {
  91         unimplemented!()
  92     }
  93 }
  94
  95 struct Lt2<'a> {
  96     foo: &'a u32,
  97 }
  98
  99 impl<'a> Lt2<'a> {
 100     // The lifetime is different, but that’s irrelevant; see issue #734.
 101     pub fn new(s: &str) -> Lt2 {
 102         unimplemented!()
 103     }
 104 }
 105
 106 struct Lt3<'a> {
 107     foo: &'a u32,
 108 }
 109
 110 impl<'a> Lt3<'a> {
 111     // The lifetime is different, but that’s irrelevant; see issue #734.
 112     pub fn new() -> Lt3<'static> {
 113         unimplemented!()
 114     }
 115 }
 116
 117 #[derive(Clone, Copy)]
 118 struct U;
 119
 120 impl U {
 121     fn new() -> Self {
 122         U
 123     }
 124     // Ok because `U` is `Copy`.
 125     fn to_something(self) -> u32 {
 126         0
 127     }
 128 }
 129
 130 struct V<T> {
 131     _dummy: T,
 132 }
 133
 134 impl<T> V<T> {
 135     fn new() -> Option<V<T>> {
 136         None
 137     }
 138 }
 139
 140 impl Mul<T> for T {
 141     type Output = T;
 142     // No error, obviously.
 143     fn mul(self, other: T) -> T {
 144         self
 145     }
 146 }
 147
 148 /// Checks implementation of the following lints:
 149 /// * `OPTION_MAP_UNWRAP_OR`
 150 /// * `OPTION_MAP_UNWRAP_OR_ELSE`
 151 /// * `OPTION_MAP_OR_NONE`
 152 #[rustfmt::skip]
 153 fn option_methods() {
 154     let opt = Some(1);
 155
 156     // Check `OPTION_MAP_UNWRAP_OR`.
 157     // Single line case.
 158     let _ = opt.map(|x| x + 1)
 159                 // Should lint even though this call is on a separate line.
 160                .unwrap_or(0);
 161     // Multi-line cases.
 162     let _ = opt.map(|x| {
 163                         x + 1
 164                     }
 165               ).unwrap_or(0);
 166     let _ = opt.map(|x| x + 1)
 167                .unwrap_or({
 168                     0
 169                 });
 170     // Single line `map(f).unwrap_or(None)` case.
 171     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
 172     // Multi-line `map(f).unwrap_or(None)` cases.
 173     let _ = opt.map(|x| {
 174         Some(x + 1)
 175     }
 176     ).unwrap_or(None);
 177     let _ = opt
 178         .map(|x| Some(x + 1))
 179         .unwrap_or(None);
 180     // macro case
 181     let _ = opt_map!(opt, |x| x + 1).unwrap_or(0); // should not lint
 182
 183     // Should not lint if not copyable
 184     let id: String = "identifier".to_string();
 185     let _ = Some("prefix").map(|p| format!("{}.{}", p, id)).unwrap_or(id);
 186     // ...but DO lint if the `unwrap_or` argument is not used in the `map`
 187     let id: String = "identifier".to_string();
 188     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
 189
 190     // Check OPTION_MAP_UNWRAP_OR_ELSE
 191     // single line case
 192     let _ = opt.map(|x| x + 1)
 193                 // Should lint even though this call is on a separate line.
 194                .unwrap_or_else(|| 0);
 195     // Multi-line cases.
 196     let _ = opt.map(|x| {
 197                         x + 1
 198                     }
 199               ).unwrap_or_else(|| 0);
 200     let _ = opt.map(|x| x + 1)
 201                .unwrap_or_else(||
 202                     0
 203                 );
 204     // Macro case.
 205     // Should not lint.
 206     let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
 207
 208     // Check `OPTION_MAP_OR_NONE`.
 209     // Single line case.
 210     let _ = opt.map_or(None, |x| Some(x + 1));
 211     // Multi-line case.
 212     let _ = opt.map_or(None, |x| {
 213                         Some(x + 1)
 214                        }
 215                 );
 216 }
 217
 218 /// Struct to generate false positives for things with `.iter()`.
 219 #[derive(Copy, Clone)]
 220 struct HasIter;
 221
 222 impl HasIter {
 223     fn iter(self) -> IteratorFalsePositives {
 224         IteratorFalsePositives { foo: 0 }
 225     }
 226
 227     fn iter_mut(self) -> IteratorFalsePositives {
 228         IteratorFalsePositives { foo: 0 }
 229     }
 230 }
 231
 232 /// Checks implementation of `FILTER_NEXT` lint.
 233 #[rustfmt::skip]
 234 fn filter_next() {
 235     let v = vec![3, 2, 1, 0, -1, -2, -3];
 236
 237     // Single-line case.
 238     let _ = v.iter().filter(|&x| *x < 0).next();
 239
 240     // Multi-line case.
 241     let _ = v.iter().filter(|&x| {
 242                                 *x < 0
 243                             }
 244                    ).next();
 245
 246     // Check that hat we don't lint if the caller is not an `Iterator`.
 247     let foo = IteratorFalsePositives { foo: 0 };
 248     let _ = foo.filter().next();
 249 }
 250
 251 /// Checks implementation of `SEARCH_IS_SOME` lint.
 252 #[rustfmt::skip]
 253 fn search_is_some() {
 254     let v = vec![3, 2, 1, 0, -1, -2, -3];
 255
 256     // Check `find().is_some()`, single-line case.
 257     let _ = v.iter().find(|&x| *x < 0).is_some();
 258
 259     // Check `find().is_some()`, multi-line case.
 260     let _ = v.iter().find(|&x| {
 261                               *x < 0
 262                           }
 263                    ).is_some();
 264
 265     // Check `position().is_some()`, single-line case.
 266     let _ = v.iter().position(|&x| x < 0).is_some();
 267
 268     // Check `position().is_some()`, multi-line case.
 269     let _ = v.iter().position(|&x| {
 270                                   x < 0
 271                               }
 272                    ).is_some();
 273
 274     // Check `rposition().is_some()`, single-line case.
 275     let _ = v.iter().rposition(|&x| x < 0).is_some();
 276
 277     // Check `rposition().is_some()`, multi-line case.
 278     let _ = v.iter().rposition(|&x| {
 279                                    x < 0
 280                                }
 281                    ).is_some();
 282
 283     // Check that we don't lint if the caller is not an `Iterator`.
 284     let foo = IteratorFalsePositives { foo: 0 };
 285     let _ = foo.find().is_some();
 286     let _ = foo.position().is_some();
 287     let _ = foo.rposition().is_some();
 288 }
 289
 290 /// Checks implementation of `ITER_NTH` lint.
 291 fn iter_nth() {
 292     let mut some_vec = vec![0, 1, 2, 3];
 293     let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
 294     let mut some_vec_deque: VecDeque<_> = some_vec.iter().cloned().collect();
 295
 296     {
 297         // Make sure we lint `.iter()` for relevant types.
 298         let bad_vec = some_vec.iter().nth(3);
 299         let bad_slice = &some_vec[..].iter().nth(3);
 300         let bad_boxed_slice = boxed_slice.iter().nth(3);
 301         let bad_vec_deque = some_vec_deque.iter().nth(3);
 302     }
 303
 304     {
 305         // Make sure we lint `.iter_mut()` for relevant types.
 306         let bad_vec = some_vec.iter_mut().nth(3);
 307     }
 308     {
 309         let bad_slice = &some_vec[..].iter_mut().nth(3);
 310     }
 311     {
 312         let bad_vec_deque = some_vec_deque.iter_mut().nth(3);
 313     }
 314
 315     // Make sure we don't lint for non-relevant types.
 316     let false_positive = HasIter;
 317     let ok = false_positive.iter().nth(3);
 318     let ok_mut = false_positive.iter_mut().nth(3);
 319 }
 320
 321 #[allow(clippy::similar_names)]
 322 fn main() {
 323     let opt = Some(0);
 324     let _ = opt.unwrap();
 325 }