Add return value support to overload! macro

.github/workflows/check.yml

@@ -54,6 +54,12 @@ jobs:
         run: |
           cargo run --all-features --bin multiple-args
           cargo run --all-features --bin multiple-mixed-args
+          cargo run --all-features --bin return-values
+          cargo run --all-features --bin return-values-mixed-args
+          cargo run --all-features --bin return-values-mixed-unit
+          cargo run --all-features --bin return-values-complex
+          cargo run --all-features --bin return-values-non-copy
+          cargo run --all-features --bin return-values-zero-args
 
   clippy-rust:
     name: 4. Clippy lints on Rust crates

splat-overload-test/src/bin/return-values-complex.rs

@@ -0,0 +1,35 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features)]
+#![allow(unused_braces)]
+
+use splat_overload::overload;
+
+overload! {
+    fn foo(x: i32) -> i32 {
+        if x < 0 {
+            return 0;
+        }
+        x * 2
+    }
+    fn foo(x: i32, y: i32) -> Vec<i32> { vec![x, y] }
+    fn foo(x: i32, y: i32, z: i32) -> String { format!("{}-{}-{}", x, y, z) }
+}
+
+fn main() {
+    let a = foo(-5);
+    assert_eq!(a, 0);
+    println!("early return result: {}", a);
+
+    let b = foo(10);
+    assert_eq!(b, 20);
+    println!("normal path result: {}", b);
+
+    let c = foo(1i32, 2);
+    assert_eq!(c, vec![1, 2]);
+    println!("vec result: {:?}", c);
+
+    let d = foo(1i32, 2, 3);
+    assert_eq!(d, "1-2-3");
+    println!("string result: {}", d);
+}

splat-overload-test/src/bin/return-values-mixed-args.rs

@@ -0,0 +1,21 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features)]
+#![allow(unused_braces)]
+
+use splat_overload::overload;
+
+overload! {
+    fn foo(x: f64, y: i32) -> i32 { (x as i32) + y }
+    fn foo(x: i32) -> i32 { x * 2 }
+}
+
+fn main() {
+    let a = foo(3.7, 10);
+    assert_eq!(a, 13);
+    println!("mixed args result: {}", a);
+
+    let b = foo(21);
+    assert_eq!(b, 42);
+    println!("single arg result: {}", b);
+}

splat-overload-test/src/bin/return-values-mixed-unit.rs

@@ -0,0 +1,19 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features)]
+#![allow(unused_braces)]
+
+use splat_overload::overload;
+
+overload! {
+    fn foo(x: i32) -> i32 { x * 2 }
+    fn foo(x: f64) { println!("f64: {}", x); }
+}
+
+fn main() {
+    let a = foo(21);
+    assert_eq!(a, 42);
+    println!("i32 result: {}", a);
+    foo(2.5);
+    println!("f64 call completed");
+}

splat-overload-test/src/bin/return-values-non-copy.rs

@@ -0,0 +1,21 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features)]
+#![allow(unused_braces)]
+
+use splat_overload::overload;
+
+overload! {
+    fn foo(x: String) -> String { x }
+    fn foo(x: String, y: String) -> String { format!("{}{}", x, y) }
+}
+
+fn main() {
+    let a = foo("We love Rust!".to_string());
+    assert_eq!(a, "We love Rust!");
+    println!("single string result: {}", a);
+
+    let b = foo("We love ".to_string(), "Rust!".to_string());
+    assert_eq!(b, "We love Rust!");
+    println!("concatenated result: {}", b);
+}

splat-overload-test/src/bin/return-values-zero-args.rs

@@ -0,0 +1,21 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features)]
+#![allow(unused_braces)]
+
+use splat_overload::overload;
+
+overload! {
+    fn foo() -> i32 { 42 }
+    fn foo(x: i32) -> i32 { x }
+}
+
+fn main() {
+    let a = foo();
+    assert_eq!(a, 42);
+    println!("zero args result: {}", a);
+
+    let b = foo(10i32);
+    assert_eq!(b, 10);
+    println!("one arg result: {}", b);
+}

splat-overload-test/src/bin/return-values.rs

@@ -0,0 +1,21 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features)]
+#![allow(unused_braces)]
+
+use splat_overload::overload;
+
+overload! {
+    fn foo(x: i32) -> i32 { x * 2 }
+    fn foo(x: f64) -> f64 { x * 2.0 }
+}
+
+fn main() {
+    let a = foo(21);
+    assert_eq!(a, 42);
+    println!("i32 result: {}", a);
+
+    let b = foo(1.5);
+    assert_eq!(b, 3.0);
+    println!("f64 result: {}", b);
+}

splat-overload/src/lib.rs

@@ -64,9 +64,23 @@ pub fn overload(input: TokenStream) -> TokenStream {
                 arg_indices.push(quote! { self.#index });
             }
         }
+
+        let output_ty = match &func.sig.output {
+            syn::ReturnType::Default => quote! { () },
+            syn::ReturnType::Type(_, ty) => quote! { #ty },
+        };
+
+        // Check if there are no arguments
+        let tuple_ty = if arg_types.is_empty() {
+            quote! { () }
+        } else {
+            quote! { (#(#arg_types),*,) }
+        };
+
         impls.push(quote! {
-            impl #trait_name for (#(#arg_types),*,) {
-                fn call(self) {
+            impl #trait_name for #tuple_ty {
+                type Output = #output_ty;
+                fn call(self) -> Self::Output{
                     #(let #arg_names = #arg_indices;)*
                     #block
                 }
@@ -75,12 +89,13 @@ pub fn overload(input: TokenStream) -> TokenStream {
     }
     let generated = quote! {
         trait #trait_name: std::marker::Tuple {
-            fn call(self);
+            type Output;
+            fn call(self) -> Self::Output;
         }
 
         #(#impls)*
 
-        fn #fn_name<T: #trait_name>(#[splat] args: T) {
+        fn #fn_name<T: #trait_name>(#[splat] args: T) -> T::Output{
             args.call()
         }
     };