iterate List by value

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

diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 395271b37ebe638ac58575f81846131104ce5153..7880cf36415ff87acc8ba620ceb7712ec8038e35 100644 (file)
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -1,18 +1,22 @@
 // aux-build:option_helpers.rs
+// 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::new_ret_no_self,
-    clippy::useless_format
+    clippy::useless_format,
+    clippy::wrong_self_convention,
+    clippy::unused_self,
+    unused
 )]
 
 #[macro_use]
@@ -80,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,
 }
@@ -137,6 +155,22 @@ fn new() -> Option<V<T>> {
     }
 }
 
+struct AsyncNew;
+
+impl AsyncNew {
+    async fn new() -> Option<Self> {
+        None
+    }
+}
+
+struct BadNew;
+
+impl BadNew {
+    fn new() -> i32 {
+        0
+    }
+}
+
 impl Mul<T> for T {
     type Output = T;
     // No error, obviously.
@@ -145,66 +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);
-}
-
 /// Checks implementation of `FILTER_NEXT` lint.
 #[rustfmt::skip]
 fn filter_next() {
@@ -228,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| {
@@ -263,26 +241,7 @@ fn search_is_some() {
     let _ = foo.rposition().is_some();
 }
 
-#[allow(clippy::similar_names)]
 fn main() {
-    let opt = Some(0);
-    let _ = opt.unwrap();
-}
-
-struct Foo(u8);
-#[rustfmt::skip]
-fn test_or_with_ctors() {
-    let opt = Some(1);
-    let opt_opt = Some(Some(1));
-    // we also test for const promotion, this makes sure we don't hit that
-    let two = 2;
-
-    let _ = opt_opt.unwrap_or(Some(2));
-    let _ = opt_opt.unwrap_or(Some(two));
-    let _ = opt.ok_or(Some(2));
-    let _ = opt.ok_or(Some(two));
-    let _ = opt.ok_or(Foo(2));
-    let _ = opt.ok_or(Foo(two));
-    let _ = opt.or(Some(2));
-    let _ = opt.or(Some(two));
+    filter_next();
+    search_is_some();
 }