tests/ui/methods.rs

   1 #![feature(plugin)]
   2 #![feature(const_fn)]
   3 #![plugin(clippy)]
   4
   5 #![warn(clippy, clippy_pedantic)]
   6 #![allow(blacklisted_name, unused, print_stdout, non_ascii_literal, new_without_default, new_without_default_derive, missing_docs_in_private_items)]
   7
   8 use std::collections::BTreeMap;
   9 use std::collections::HashMap;
  10 use std::collections::HashSet;
  11 use std::collections::VecDeque;
  12 use std::ops::Mul;
  13 use std::iter::FromIterator;
  14 use std::rc::{self, Rc};
  15 use std::sync::{self, Arc};
  16
  17 struct T;
  18
  19 impl T {
  20     fn add(self, other: T) -> T { self }
  21     fn drop(&mut self) { }
  22
  23     fn sub(&self, other: T) -> &T { self } // no error, self is a ref
  24     fn div(self) -> T { self } // no error, different #arguments
  25     fn rem(self, other: T) { } // no error, wrong return type
  26
  27     fn into_u32(self) -> u32 { 0 } // fine
  28     fn into_u16(&self) -> u16 { 0 }
  29
  30     fn to_something(self) -> u32 { 0 }
  31
  32     fn new(self) {}
  33 }
  34
  35 struct Lt<'a> {
  36     foo: &'a u32,
  37 }
  38
  39 impl<'a> Lt<'a> {
  40     // The lifetime is different, but that’s irrelevant, see #734
  41     #[allow(needless_lifetimes)]
  42     pub fn new<'b>(s: &'b str) -> Lt<'b> { unimplemented!() }
  43 }
  44
  45 struct Lt2<'a> {
  46     foo: &'a u32,
  47 }
  48
  49 impl<'a> Lt2<'a> {
  50     // The lifetime is different, but that’s irrelevant, see #734
  51     pub fn new(s: &str) -> Lt2 { unimplemented!() }
  52 }
  53
  54 struct Lt3<'a> {
  55     foo: &'a u32,
  56 }
  57
  58 impl<'a> Lt3<'a> {
  59     // The lifetime is different, but that’s irrelevant, see #734
  60     pub fn new() -> Lt3<'static> { unimplemented!() }
  61 }
  62
  63 #[derive(Clone,Copy)]
  64 struct U;
  65
  66 impl U {
  67     fn new() -> Self { U }
  68     fn to_something(self) -> u32 { 0 } // ok because U is Copy
  69 }
  70
  71 struct V<T> {
  72     _dummy: T
  73 }
  74
  75 impl<T> V<T> {
  76     fn new() -> Option<V<T>> { None }
  77 }
  78
  79 impl Mul<T> for T {
  80     type Output = T;
  81     fn mul(self, other: T) -> T { self } // no error, obviously
  82 }
  83
  84 /// Utility macro to test linting behavior in `option_methods()`
  85 /// The lints included in `option_methods()` should not lint if the call to map is partially
  86 /// within a macro
  87 macro_rules! opt_map {
  88     ($opt:expr, $map:expr) => {($opt).map($map)};
  89 }
  90
  91 /// Checks implementation of the following lints:
  92 /// * `OPTION_MAP_UNWRAP_OR`
  93 /// * `OPTION_MAP_UNWRAP_OR_ELSE`
  94 fn option_methods() {
  95     let opt = Some(1);
  96
  97     // Check OPTION_MAP_UNWRAP_OR
  98     // single line case
  99     let _ = opt.map(|x| x + 1)
 100
 101                .unwrap_or(0); // should lint even though this call is on a separate line
 102     // multi line cases
 103     let _ = opt.map(|x| {
 104                         x + 1
 105                     }
 106               ).unwrap_or(0);
 107     let _ = opt.map(|x| x + 1)
 108                .unwrap_or({
 109                     0
 110                 });
 111     // macro case
 112     let _ = opt_map!(opt, |x| x + 1).unwrap_or(0); // should not lint
 113
 114     // Check OPTION_MAP_UNWRAP_OR_ELSE
 115     // single line case
 116     let _ = opt.map(|x| x + 1)
 117
 118                .unwrap_or_else(|| 0); // should lint even though this call is on a separate line
 119     // multi line cases
 120     let _ = opt.map(|x| {
 121                         x + 1
 122                     }
 123               ).unwrap_or_else(|| 0);
 124     let _ = opt.map(|x| x + 1)
 125                .unwrap_or_else(||
 126                     0
 127                 );
 128     // macro case
 129     let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0); // should not lint
 130 }
 131
 132 /// Struct to generate false positives for things with .iter()
 133 #[derive(Copy, Clone)]
 134 struct HasIter;
 135
 136 impl HasIter {
 137     fn iter(self) -> IteratorFalsePositives {
 138         IteratorFalsePositives { foo: 0 }
 139     }
 140
 141     fn iter_mut(self) -> IteratorFalsePositives {
 142         IteratorFalsePositives { foo: 0 }
 143     }
 144 }
 145
 146 /// Struct to generate false positive for Iterator-based lints
 147 #[derive(Copy, Clone)]
 148 struct IteratorFalsePositives {
 149     foo: u32,
 150 }
 151
 152 impl IteratorFalsePositives {
 153     fn filter(self) -> IteratorFalsePositives {
 154         self
 155     }
 156
 157     fn next(self) -> IteratorFalsePositives {
 158         self
 159     }
 160
 161     fn find(self) -> Option<u32> {
 162         Some(self.foo)
 163     }
 164
 165     fn position(self) -> Option<u32> {
 166         Some(self.foo)
 167     }
 168
 169     fn rposition(self) -> Option<u32> {
 170         Some(self.foo)
 171     }
 172
 173     fn nth(self, n: usize) -> Option<u32> {
 174         Some(self.foo)
 175     }
 176
 177     fn skip(self, _: usize) -> IteratorFalsePositives {
 178         self
 179     }
 180 }
 181
 182 #[derive(Copy, Clone)]
 183 struct HasChars;
 184
 185 impl HasChars {
 186     fn chars(self) -> std::str::Chars<'static> {
 187         "HasChars".chars()
 188     }
 189 }
 190
 191 /// Checks implementation of `FILTER_NEXT` lint
 192 fn filter_next() {
 193     let v = vec![3, 2, 1, 0, -1, -2, -3];
 194
 195     // check single-line case
 196     let _ = v.iter().filter(|&x| *x < 0).next();
 197
 198     // check multi-line case
 199     let _ = v.iter().filter(|&x| {
 200                                 *x < 0
 201                             }
 202                    ).next();
 203
 204     // check that we don't lint if the caller is not an Iterator
 205     let foo = IteratorFalsePositives { foo: 0 };
 206     let _ = foo.filter().next();
 207 }
 208
 209 /// Checks implementation of `SEARCH_IS_SOME` lint
 210 fn search_is_some() {
 211     let v = vec![3, 2, 1, 0, -1, -2, -3];
 212
 213     // check `find().is_some()`, single-line
 214     let _ = v.iter().find(|&x| *x < 0).is_some();
 215
 216     // check `find().is_some()`, multi-line
 217     let _ = v.iter().find(|&x| {
 218                               *x < 0
 219                           }
 220                    ).is_some();
 221
 222     // check `position().is_some()`, single-line
 223     let _ = v.iter().position(|&x| x < 0).is_some();
 224
 225     // check `position().is_some()`, multi-line
 226     let _ = v.iter().position(|&x| {
 227                                   x < 0
 228                               }
 229                    ).is_some();
 230
 231     // check `rposition().is_some()`, single-line
 232     let _ = v.iter().rposition(|&x| x < 0).is_some();
 233
 234     // check `rposition().is_some()`, multi-line
 235     let _ = v.iter().rposition(|&x| {
 236                                    x < 0
 237                                }
 238                    ).is_some();
 239
 240     // check that we don't lint if the caller is not an Iterator
 241     let foo = IteratorFalsePositives { foo: 0 };
 242     let _ = foo.find().is_some();
 243     let _ = foo.position().is_some();
 244     let _ = foo.rposition().is_some();
 245 }
 246
 247 /// Checks implementation of the `OR_FUN_CALL` lint
 248 fn or_fun_call() {
 249     struct Foo;
 250
 251     impl Foo {
 252         fn new() -> Foo { Foo }
 253     }
 254
 255     enum Enum {
 256         A(i32),
 257     }
 258
 259     const fn make_const(i: i32) -> i32 { i }
 260
 261     fn make<T>() -> T { unimplemented!(); }
 262
 263     let with_enum = Some(Enum::A(1));
 264     with_enum.unwrap_or(Enum::A(5));
 265
 266     let with_const_fn = Some(1);
 267     with_const_fn.unwrap_or(make_const(5));
 268
 269     let with_constructor = Some(vec![1]);
 270     with_constructor.unwrap_or(make());
 271
 272     let with_new = Some(vec![1]);
 273     with_new.unwrap_or(Vec::new());
 274
 275     let with_const_args = Some(vec![1]);
 276     with_const_args.unwrap_or(Vec::with_capacity(12));
 277
 278     let with_err : Result<_, ()> = Ok(vec![1]);
 279     with_err.unwrap_or(make());
 280
 281     let with_err_args : Result<_, ()> = Ok(vec![1]);
 282     with_err_args.unwrap_or(Vec::with_capacity(12));
 283
 284     let with_default_trait = Some(1);
 285     with_default_trait.unwrap_or(Default::default());
 286
 287     let with_default_type = Some(1);
 288     with_default_type.unwrap_or(u64::default());
 289
 290     let with_vec = Some(vec![1]);
 291     with_vec.unwrap_or(vec![]);
 292
 293     // FIXME #944: ~|SUGGESTION with_vec.unwrap_or_else(|| vec![]);
 294
 295     let without_default = Some(Foo);
 296     without_default.unwrap_or(Foo::new());
 297
 298     let mut map = HashMap::<u64, String>::new();
 299     map.entry(42).or_insert(String::new());
 300
 301     let mut btree = BTreeMap::<u64, String>::new();
 302     btree.entry(42).or_insert(String::new());
 303
 304     let stringy = Some(String::from(""));
 305     let _ = stringy.unwrap_or("".to_owned());
 306 }
 307
 308 /// Checks implementation of `ITER_NTH` lint
 309 fn iter_nth() {
 310     let mut some_vec = vec![0, 1, 2, 3];
 311     let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
 312     let mut some_vec_deque: VecDeque<_> = some_vec.iter().cloned().collect();
 313
 314     {
 315         // Make sure we lint `.iter()` for relevant types
 316         let bad_vec = some_vec.iter().nth(3);
 317         let bad_slice = &some_vec[..].iter().nth(3);
 318         let bad_boxed_slice = boxed_slice.iter().nth(3);
 319         let bad_vec_deque = some_vec_deque.iter().nth(3);
 320     }
 321
 322     {
 323         // Make sure we lint `.iter_mut()` for relevant types
 324         let bad_vec = some_vec.iter_mut().nth(3);
 325     }
 326     {
 327         let bad_slice = &some_vec[..].iter_mut().nth(3);
 328     }
 329     {
 330         let bad_vec_deque = some_vec_deque.iter_mut().nth(3);
 331     }
 332
 333     // Make sure we don't lint for non-relevant types
 334     let false_positive = HasIter;
 335     let ok = false_positive.iter().nth(3);
 336     let ok_mut = false_positive.iter_mut().nth(3);
 337 }
 338
 339 /// Checks implementation of `ITER_SKIP_NEXT` lint
 340 fn iter_skip_next() {
 341     let mut some_vec = vec![0, 1, 2, 3];
 342     let _ = some_vec.iter().skip(42).next();
 343     let _ = some_vec.iter().cycle().skip(42).next();
 344     let _ = (1..10).skip(10).next();
 345     let _ = &some_vec[..].iter().skip(3).next();
 346     let foo = IteratorFalsePositives { foo : 0 };
 347     let _ = foo.skip(42).next();
 348     let _ = foo.filter().skip(42).next();
 349 }
 350
 351 struct GetFalsePositive {
 352     arr: [u32; 3],
 353 }
 354
 355 impl GetFalsePositive {
 356     fn get(&self, pos: usize) -> Option<&u32> { self.arr.get(pos) }
 357     fn get_mut(&mut self, pos: usize) -> Option<&mut u32> { self.arr.get_mut(pos) }
 358 }
 359
 360 /// Checks implementation of `GET_UNWRAP` lint
 361 fn get_unwrap() {
 362     let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
 363     let mut some_slice = &mut [0, 1, 2, 3];
 364     let mut some_vec = vec![0, 1, 2, 3];
 365     let mut some_vecdeque: VecDeque<_> = some_vec.iter().cloned().collect();
 366     let mut some_hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(1, 'a'), (2, 'b')]);
 367     let mut some_btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(1, 'a'), (2, 'b')]);
 368     let mut false_positive = GetFalsePositive { arr: [0, 1, 2] };
 369
 370     { // Test `get().unwrap()`
 371         let _ = boxed_slice.get(1).unwrap();
 372         let _ = some_slice.get(0).unwrap();
 373         let _ = some_vec.get(0).unwrap();
 374         let _ = some_vecdeque.get(0).unwrap();
 375         let _ = some_hashmap.get(&1).unwrap();
 376         let _ = some_btreemap.get(&1).unwrap();
 377         let _ = false_positive.get(0).unwrap();
 378     }
 379
 380     { // Test `get_mut().unwrap()`
 381         *boxed_slice.get_mut(0).unwrap() = 1;
 382         *some_slice.get_mut(0).unwrap() = 1;
 383         *some_vec.get_mut(0).unwrap() = 1;
 384         *some_vecdeque.get_mut(0).unwrap() = 1;
 385         // Check false positives
 386         *some_hashmap.get_mut(&1).unwrap() = 'b';
 387         *some_btreemap.get_mut(&1).unwrap() = 'b';
 388         *false_positive.get_mut(0).unwrap() = 1;
 389     }
 390 }
 391
 392
 393 #[allow(similar_names)]
 394 fn main() {
 395     use std::io;
 396
 397     let opt = Some(0);
 398     let _ = opt.unwrap();
 399
 400     let res: Result<i32, ()> = Ok(0);
 401     let _ = res.unwrap();
 402
 403     res.ok().expect("disaster!");
 404     // the following should not warn, since `expect` isn't implemented unless
 405     // the error type implements `Debug`
 406     let res2: Result<i32, MyError> = Ok(0);
 407     res2.ok().expect("oh noes!");
 408     let res3: Result<u32, MyErrorWithParam<u8>>= Ok(0);
 409     res3.ok().expect("whoof");
 410     let res4: Result<u32, io::Error> = Ok(0);
 411     res4.ok().expect("argh");
 412     let res5: io::Result<u32> = Ok(0);
 413     res5.ok().expect("oops");
 414     let res6: Result<u32, &str> = Ok(0);
 415     res6.ok().expect("meh");
 416 }
 417
 418 struct MyError(()); // doesn't implement Debug
 419
 420 #[derive(Debug)]
 421 struct MyErrorWithParam<T> {
 422     x: T
 423 }
 424
 425 #[allow(unnecessary_operation)]
 426 fn starts_with() {
 427     "".chars().next() == Some(' ');
 428     Some(' ') != "".chars().next();
 429 }
 430
 431 fn str_extend_chars() {
 432     let abc = "abc";
 433     let def = String::from("def");
 434     let mut s = String::new();
 435
 436     s.push_str(abc);
 437     s.extend(abc.chars());
 438
 439     s.push_str("abc");
 440     s.extend("abc".chars());
 441
 442     s.push_str(&def);
 443     s.extend(def.chars());
 444
 445     s.extend(abc.chars().skip(1));
 446     s.extend("abc".chars().skip(1));
 447     s.extend(['a', 'b', 'c'].iter());
 448
 449     let f = HasChars;
 450     s.extend(f.chars());
 451 }
 452
 453 fn clone_on_copy() {
 454     42.clone();
 455
 456     vec![1].clone(); // ok, not a Copy type
 457     Some(vec![1]).clone(); // ok, not a Copy type
 458     (&42).clone();
 459 }
 460
 461 fn clone_on_ref_ptr() {
 462     let rc = Rc::new(true);
 463     let arc = Arc::new(true);
 464
 465     let rcweak = Rc::downgrade(&rc);
 466     let arc_weak = Arc::downgrade(&arc);
 467
 468     rc.clone();
 469     Rc::clone(&rc);
 470
 471     arc.clone();
 472     Arc::clone(&arc);
 473
 474     rcweak.clone();
 475     rc::Weak::clone(&rcweak);
 476
 477     arc_weak.clone();
 478     sync::Weak::clone(&arc_weak);
 479
 480
 481 }
 482
 483 fn clone_on_copy_generic<T: Copy>(t: T) {
 484     t.clone();
 485
 486     Some(t).clone();
 487 }
 488
 489 fn clone_on_double_ref() {
 490     let x = vec![1];
 491     let y = &&x;
 492     let z: &Vec<_> = y.clone();
 493
 494     println!("{:p} {:p}",*y, z);
 495 }
 496
 497 fn single_char_pattern() {
 498     let x = "foo";
 499     x.split("x");
 500     x.split("xx");
 501     x.split('x');
 502
 503     let y = "x";
 504     x.split(y);
 505     // Not yet testing for multi-byte characters
 506     // Changing `r.len() == 1` to `r.chars().count() == 1` in `lint_single_char_pattern`
 507     // should have done this but produced an ICE
 508     //
 509     // We may not want to suggest changing these anyway
 510     // See: https://github.com/rust-lang-nursery/rust-clippy/issues/650#issuecomment-184328984
 511     x.split("ß");
 512     x.split("ℝ");
 513     x.split("💣");
 514     // Can't use this lint for unicode code points which don't fit in a char
 515     x.split("❤️");
 516     x.contains("x");
 517     x.starts_with("x");
 518     x.ends_with("x");
 519     x.find("x");
 520     x.rfind("x");
 521     x.rsplit("x");
 522     x.split_terminator("x");
 523     x.rsplit_terminator("x");
 524     x.splitn(0, "x");
 525     x.rsplitn(0, "x");
 526     x.matches("x");
 527     x.rmatches("x");
 528     x.match_indices("x");
 529     x.rmatch_indices("x");
 530     x.trim_left_matches("x");
 531     x.trim_right_matches("x");
 532
 533     let h = HashSet::<String>::new();
 534     h.contains("X"); // should not warn
 535 }
 536
 537 #[allow(result_unwrap_used)]
 538 fn temporary_cstring() {
 539     use std::ffi::CString;
 540
 541     CString::new("foo").unwrap().as_ptr();
 542 }
 543
 544 fn iter_clone_collect() {
 545     let v = [1,2,3,4,5];
 546     let v2 : Vec<isize> = v.iter().cloned().collect();
 547     let v3 : HashSet<isize> = v.iter().cloned().collect();
 548     let v4 : VecDeque<isize> = v.iter().cloned().collect();
 549 }