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 /// Checks implementation of `FILTER_NEXT` lint.
 219 #[rustfmt::skip]
 220 fn filter_next() {
 221     let v = vec![3, 2, 1, 0, -1, -2, -3];
 222
 223     // Single-line case.
 224     let _ = v.iter().filter(|&x| *x < 0).next();
 225
 226     // Multi-line case.
 227     let _ = v.iter().filter(|&x| {
 228                                 *x < 0
 229                             }
 230                    ).next();
 231
 232     // Check that hat we don't lint if the caller is not an `Iterator`.
 233     let foo = IteratorFalsePositives { foo: 0 };
 234     let _ = foo.filter().next();
 235 }
 236
 237 /// Checks implementation of `SEARCH_IS_SOME` lint.
 238 #[rustfmt::skip]
 239 fn search_is_some() {
 240     let v = vec![3, 2, 1, 0, -1, -2, -3];
 241
 242     // Check `find().is_some()`, single-line case.
 243     let _ = v.iter().find(|&x| *x < 0).is_some();
 244
 245     // Check `find().is_some()`, multi-line case.
 246     let _ = v.iter().find(|&x| {
 247                               *x < 0
 248                           }
 249                    ).is_some();
 250
 251     // Check `position().is_some()`, single-line case.
 252     let _ = v.iter().position(|&x| x < 0).is_some();
 253
 254     // Check `position().is_some()`, multi-line case.
 255     let _ = v.iter().position(|&x| {
 256                                   x < 0
 257                               }
 258                    ).is_some();
 259
 260     // Check `rposition().is_some()`, single-line case.
 261     let _ = v.iter().rposition(|&x| x < 0).is_some();
 262
 263     // Check `rposition().is_some()`, multi-line case.
 264     let _ = v.iter().rposition(|&x| {
 265                                    x < 0
 266                                }
 267                    ).is_some();
 268
 269     // Check that we don't lint if the caller is not an `Iterator`.
 270     let foo = IteratorFalsePositives { foo: 0 };
 271     let _ = foo.find().is_some();
 272     let _ = foo.position().is_some();
 273     let _ = foo.rposition().is_some();
 274 }
 275
 276 #[allow(clippy::similar_names)]
 277 fn main() {
 278     let opt = Some(0);
 279     let _ = opt.unwrap();
 280 }