iterate List by value

[rust.git] / tests / ui / methods.rs

diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 53f9f82485d140664432841319ddc5fdc46c9486..7880cf36415ff87acc8ba620ceb7712ec8038e35 100644 (file)
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -1,19 +1,22 @@
 // aux-build:option_helpers.rs
-// compile-flags: --edition 2018
+// edition:2018
 
-#![warn(clippy::all, clippy::pedantic, clippy::option_unwrap_used)]
+#![warn(clippy::all, clippy::pedantic)]
 #![allow(
     clippy::blacklisted_name,
-    unused,
-    clippy::print_stdout,
+    clippy::default_trait_access,
+    clippy::missing_docs_in_private_items,
+    clippy::missing_safety_doc,
     clippy::non_ascii_literal,
     clippy::new_without_default,
-    clippy::missing_docs_in_private_items,
     clippy::needless_pass_by_value,
-    clippy::default_trait_access,
+    clippy::print_stdout,
+    clippy::must_use_candidate,
     clippy::use_self,
     clippy::useless_format,
-    clippy::wrong_self_convention
+    clippy::wrong_self_convention,
+    clippy::unused_self,
+    unused
 )]
 
 #[macro_use]
@@ -81,6 +84,20 @@ fn new(self) -> Self {
     }
 }
 
+pub struct T1;
+
+impl T1 {
+    // Shouldn't trigger lint as it is unsafe.
+    pub unsafe fn add(self, rhs: T1) -> T1 {
+        self
+    }
+
+    // Should not trigger lint since this is an async function.
+    pub async fn next(&mut self) -> Option<T1> {
+        None
+    }
+}
+
 struct Lt<'a> {
     foo: &'a u32,
 }
@@ -162,81 +179,6 @@ fn mul(self, other: T) -> T {
     }
 }
 
-/// Checks implementation of the following lints:
-/// * `OPTION_MAP_UNWRAP_OR`
-/// * `OPTION_MAP_UNWRAP_OR_ELSE`
-#[rustfmt::skip]
-fn option_methods() {
-    let opt = Some(1);
-
-    // Check `OPTION_MAP_UNWRAP_OR`.
-    // Single line case.
-    let _ = opt.map(|x| x + 1)
-                // Should lint even though this call is on a separate line.
-               .unwrap_or(0);
-    // Multi-line cases.
-    let _ = opt.map(|x| {
-                        x + 1
-                    }
-              ).unwrap_or(0);
-    let _ = opt.map(|x| x + 1)
-               .unwrap_or({
-                    0
-                });
-    // Single line `map(f).unwrap_or(None)` case.
-    let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
-    // Multi-line `map(f).unwrap_or(None)` cases.
-    let _ = opt.map(|x| {
-        Some(x + 1)
-    }
-    ).unwrap_or(None);
-    let _ = opt
-        .map(|x| Some(x + 1))
-        .unwrap_or(None);
-    // macro case
-    let _ = opt_map!(opt, |x| x + 1).unwrap_or(0); // should not lint
-
-    // Should not lint if not copyable
-    let id: String = "identifier".to_string();
-    let _ = Some("prefix").map(|p| format!("{}.{}", p, id)).unwrap_or(id);
-    // ...but DO lint if the `unwrap_or` argument is not used in the `map`
-    let id: String = "identifier".to_string();
-    let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
-
-    // Check OPTION_MAP_UNWRAP_OR_ELSE
-    // single line case
-    let _ = opt.map(|x| x + 1)
-                // Should lint even though this call is on a separate line.
-               .unwrap_or_else(|| 0);
-    // Multi-line cases.
-    let _ = opt.map(|x| {
-                        x + 1
-                    }
-              ).unwrap_or_else(|| 0);
-    let _ = opt.map(|x| x + 1)
-               .unwrap_or_else(||
-                    0
-                );
-    // Macro case.
-    // Should not lint.
-    let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
-
-    // Issue #4144
-    {
-        let mut frequencies = HashMap::new();
-        let word = "foo";
-
-        frequencies
-            .get_mut(word)
-            .map(|count| {
-                *count += 1;
-            })
-            .unwrap_or_else(|| {
-                frequencies.insert(word.to_owned(), 1);
-            });
-    }
-}
-
 /// Checks implementation of `FILTER_NEXT` lint.
 #[rustfmt::skip]
 fn filter_next() {
@@ -260,9 +202,13 @@ fn filter_next() {
 #[rustfmt::skip]
 fn search_is_some() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
 
     // Check `find().is_some()`, single-line case.
     let _ = v.iter().find(|&x| *x < 0).is_some();
+    let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
+    let _ = (0..1).find(|x| *x == 0).is_some();
+    let _ = v.iter().find(|x| **x == 0).is_some();
 
     // Check `find().is_some()`, multi-line case.
     let _ = v.iter().find(|&x| {
@@ -295,8 +241,7 @@ fn search_is_some() {
     let _ = foo.rposition().is_some();
 }
 
-#[allow(clippy::similar_names)]
 fn main() {
-    let opt = Some(0);
-    let _ = opt.unwrap();
+    filter_next();
+    search_is_some();
 }