1 files changed, 240 insertions, 0 deletions
diff --git a/src/tools/clippy/tests/ui/needless_return.fixed b/src/tools/clippy/tests/ui/needless_return.fixed
new file mode 100644
index 000000000..0bc0d0011
--- /dev/null
+++ b/src/tools/clippy/tests/ui/needless_return.fixed
@@ -0,0 +1,240 @@
+// run-rustfix
+
+#![feature(lint_reasons)]
+#![feature(let_else)]
+#![allow(unused)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::single_match,
+    clippy::needless_bool,
+    clippy::equatable_if_let
+)]
+#![warn(clippy::needless_return)]
+
+use std::cell::RefCell;
+
+macro_rules! the_answer {
+    () => {
+        42
+    };
+}
+
+fn test_end_of_fn() -> bool {
+    if true {
+        // no error!
+        return true;
+    }
+    true
+}
+
+fn test_no_semicolon() -> bool {
+    true
+}
+
+fn test_if_block() -> bool {
+    if true {
+        true
+    } else {
+        false
+    }
+}
+
+fn test_match(x: bool) -> bool {
+    match x {
+        true => false,
+        false => {
+            true
+        },
+    }
+}
+
+fn test_closure() {
+    let _ = || {
+        true
+    };
+    let _ = || true;
+}
+
+fn test_macro_call() -> i32 {
+    the_answer!()
+}
+
+fn test_void_fun() {
+    
+}
+
+fn test_void_if_fun(b: bool) {
+    if b {
+        
+    } else {
+        
+    }
+}
+
+fn test_void_match(x: u32) {
+    match x {
+        0 => (),
+        _ => (),
+    }
+}
+
+fn test_nested_match(x: u32) {
+    match x {
+        0 => (),
+        1 => {
+            let _ = 42;
+            
+        },
+        _ => (),
+    }
+}
+
+fn temporary_outlives_local() -> String {
+    let x = RefCell::<String>::default();
+    return x.borrow().clone();
+}
+
+fn borrows_but_not_last(value: bool) -> String {
+    if value {
+        let x = RefCell::<String>::default();
+        let _a = x.borrow().clone();
+        String::from("test")
+    } else {
+        String::new()
+    }
+}
+
+macro_rules! needed_return {
+    ($e:expr) => {
+        if $e > 3 {
+            return;
+        }
+    };
+}
+
+fn test_return_in_macro() {
+    // This will return and the macro below won't be executed. Removing the `return` from the macro
+    // will change semantics.
+    needed_return!(10);
+    needed_return!(0);
+}
+
+mod issue6501 {
+    #[allow(clippy::unnecessary_lazy_evaluations)]
+    fn foo(bar: Result<(), ()>) {
+        bar.unwrap_or_else(|_| {})
+    }
+
+    fn test_closure() {
+        let _ = || {
+            
+        };
+        let _ = || {};
+    }
+
+    struct Foo;
+    #[allow(clippy::unnecessary_lazy_evaluations)]
+    fn bar(res: Result<Foo, u8>) -> Foo {
+        res.unwrap_or_else(|_| Foo)
+    }
+}
+
+async fn async_test_end_of_fn() -> bool {
+    if true {
+        // no error!
+        return true;
+    }
+    true
+}
+
+async fn async_test_no_semicolon() -> bool {
+    true
+}
+
+async fn async_test_if_block() -> bool {
+    if true {
+        true
+    } else {
+        false
+    }
+}
+
+async fn async_test_match(x: bool) -> bool {
+    match x {
+        true => false,
+        false => {
+            true
+        },
+    }
+}
+
+async fn async_test_closure() {
+    let _ = || {
+        true
+    };
+    let _ = || true;
+}
+
+async fn async_test_macro_call() -> i32 {
+    the_answer!()
+}
+
+async fn async_test_void_fun() {
+    
+}
+
+async fn async_test_void_if_fun(b: bool) {
+    if b {
+        
+    } else {
+        
+    }
+}
+
+async fn async_test_void_match(x: u32) {
+    match x {
+        0 => (),
+        _ => (),
+    }
+}
+
+async fn async_temporary_outlives_local() -> String {
+    let x = RefCell::<String>::default();
+    return x.borrow().clone();
+}
+
+async fn async_borrows_but_not_last(value: bool) -> String {
+    if value {
+        let x = RefCell::<String>::default();
+        let _a = x.borrow().clone();
+        String::from("test")
+    } else {
+        String::new()
+    }
+}
+
+async fn async_test_return_in_macro() {
+    needed_return!(10);
+    needed_return!(0);
+}
+
+fn let_else() {
+    let Some(1) = Some(1) else { return };
+}
+
+fn needless_return_macro() -> String {
+    let _ = "foo";
+    let _ = "bar";
+    format!("Hello {}", "world!")
+}
+
+fn check_expect() -> bool {
+    if true {
+        // no error!
+        return true;
+    }
+    #[expect(clippy::needless_return)]
+    return true;
+}
+
+fn main() {}