Auto merge of #9684 - kraktus:ref_option_ref, r=xFrednet

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

diff --git a/tests/ui/new_ret_no_self.rs b/tests/ui/new_ret_no_self.rs
index bed43f550f218539dd2d7b5868a9d63b2b8fc3e2..2f315ffe2983ebebc506b2a5eb33bf7d2f87647b 100644 (file)
--- a/tests/ui/new_ret_no_self.rs
+++ b/tests/ui/new_ret_no_self.rs
@@ -1,7 +1,7 @@
 #![warn(clippy::new_ret_no_self)]
-#![allow(dead_code, clippy::trivially_copy_pass_by_ref)]
+#![allow(dead_code)]
 
-fn main(){}
+fn main() {}
 
 trait R {
     type Item;
@@ -96,82 +96,257 @@ pub fn new(_: String) -> u32 {
 
 impl TupleReturnerOk {
     // should not trigger lint
-    pub fn new() -> (Self, u32) { unimplemented!(); }
+    pub fn new() -> (Self, u32) {
+        unimplemented!();
+    }
 }
 
 struct TupleReturnerOk2;
 
 impl TupleReturnerOk2 {
     // should not trigger lint (it doesn't matter which element in the tuple is Self)
-    pub fn new() -> (u32, Self) { unimplemented!(); }
+    pub fn new() -> (u32, Self) {
+        unimplemented!();
+    }
 }
 
 struct TupleReturnerOk3;
 
 impl TupleReturnerOk3 {
     // should not trigger lint (tuple can contain multiple Self)
-    pub fn new() -> (Self, Self) { unimplemented!(); }
+    pub fn new() -> (Self, Self) {
+        unimplemented!();
+    }
 }
 
 struct TupleReturnerBad;
 
 impl TupleReturnerBad {
     // should trigger lint
-    pub fn new() -> (u32, u32) { unimplemented!(); }
+    pub fn new() -> (u32, u32) {
+        unimplemented!();
+    }
 }
 
 struct MutPointerReturnerOk;
 
 impl MutPointerReturnerOk {
     // should not trigger lint
-    pub fn new() -> *mut Self { unimplemented!(); }
+    pub fn new() -> *mut Self {
+        unimplemented!();
+    }
 }
 
-struct MutPointerReturnerOk2;
+struct ConstPointerReturnerOk2;
 
-impl MutPointerReturnerOk2 {
+impl ConstPointerReturnerOk2 {
     // should not trigger lint
-    pub fn new() -> *const Self { unimplemented!(); }
+    pub fn new() -> *const Self {
+        unimplemented!();
+    }
 }
 
 struct MutPointerReturnerBad;
 
 impl MutPointerReturnerBad {
     // should trigger lint
-    pub fn new() -> *mut V { unimplemented!(); }
+    pub fn new() -> *mut V {
+        unimplemented!();
+    }
 }
 
 struct GenericReturnerOk;
 
 impl GenericReturnerOk {
     // should not trigger lint
-    pub fn new() -> Option<Self> { unimplemented!(); }
+    pub fn new() -> Option<Self> {
+        unimplemented!();
+    }
 }
 
 struct GenericReturnerBad;
 
 impl GenericReturnerBad {
     // should trigger lint
-    pub fn new() -> Option<u32> { unimplemented!(); }
+    pub fn new() -> Option<u32> {
+        unimplemented!();
+    }
 }
 
 struct NestedReturnerOk;
 
 impl NestedReturnerOk {
     // should not trigger lint
-    pub fn new() -> (Option<Self>, u32) { unimplemented!(); }
+    pub fn new() -> (Option<Self>, u32) {
+        unimplemented!();
+    }
 }
 
 struct NestedReturnerOk2;
 
 impl NestedReturnerOk2 {
     // should not trigger lint
-    pub fn new() -> ((Self, u32), u32) { unimplemented!(); }
+    pub fn new() -> ((Self, u32), u32) {
+        unimplemented!();
+    }
 }
 
 struct NestedReturnerOk3;
 
 impl NestedReturnerOk3 {
     // should not trigger lint
-    pub fn new() -> Option<(Self, u32)> { unimplemented!(); }
+    pub fn new() -> Option<(Self, u32)> {
+        unimplemented!();
+    }
+}
+
+struct WithLifetime<'a> {
+    cat: &'a str,
+}
+
+impl<'a> WithLifetime<'a> {
+    // should not trigger the lint, because the lifetimes are different
+    pub fn new<'b: 'a>(s: &'b str) -> WithLifetime<'b> {
+        unimplemented!();
+    }
+}
+
+mod issue5435 {
+    struct V;
+
+    pub trait TraitRetSelf {
+        // should not trigger lint
+        fn new() -> Self;
+    }
+
+    pub trait TraitRet {
+        // should trigger lint as we are in trait definition
+        fn new() -> String;
+    }
+    pub struct StructRet;
+    impl TraitRet for StructRet {
+        // should not trigger lint as we are in the impl block
+        fn new() -> String {
+            unimplemented!();
+        }
+    }
+
+    pub trait TraitRet2 {
+        // should trigger lint
+        fn new(_: String) -> String;
+    }
+
+    trait TupleReturnerOk {
+        // should not trigger lint
+        fn new() -> (Self, u32)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait TupleReturnerOk2 {
+        // should not trigger lint (it doesn't matter which element in the tuple is Self)
+        fn new() -> (u32, Self)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait TupleReturnerOk3 {
+        // should not trigger lint (tuple can contain multiple Self)
+        fn new() -> (Self, Self)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait TupleReturnerBad {
+        // should trigger lint
+        fn new() -> (u32, u32) {
+            unimplemented!();
+        }
+    }
+
+    trait MutPointerReturnerOk {
+        // should not trigger lint
+        fn new() -> *mut Self
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait ConstPointerReturnerOk2 {
+        // should not trigger lint
+        fn new() -> *const Self
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait MutPointerReturnerBad {
+        // should trigger lint
+        fn new() -> *mut V {
+            unimplemented!();
+        }
+    }
+
+    trait GenericReturnerOk {
+        // should not trigger lint
+        fn new() -> Option<Self>
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait NestedReturnerOk {
+        // should not trigger lint
+        fn new() -> (Option<Self>, u32)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait NestedReturnerOk2 {
+        // should not trigger lint
+        fn new() -> ((Self, u32), u32)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait NestedReturnerOk3 {
+        // should not trigger lint
+        fn new() -> Option<(Self, u32)>
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+}
+
+// issue #1724
+struct RetOtherSelf<T>(T);
+struct RetOtherSelfWrapper<T>(T);
+
+impl RetOtherSelf<T> {
+    fn new(t: T) -> RetOtherSelf<RetOtherSelfWrapper<T>> {
+        RetOtherSelf(RetOtherSelfWrapper(t))
+    }
 }