Add overload proc macro for #[splat] function overloading

Cargo.toml

@@ -2,9 +2,11 @@
 resolver = "3"
 members = [
     "splat-overload",
+    "splat-overload-test"
 ]
 default-members = [
     "splat-overload",
+    "splat-overload-test"
 ]
 
 [workspace.package]
@@ -24,7 +26,7 @@ readme = "README.md"
 repository = "https://github.com/rustfoundation/overloading-macros"
 # Requires #[splat] which was introduced just before 1.99 branched
 rust-version = "1.99"
-
 [workspace.dependencies]
-# Delete this package and replace it with the actual dependencies
-example = "1.1.0"
+syn = { version = "2.0.119", features = ["full"] }
+quote = "1.0.46"
+proc-macro2 = "1.0.106"

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

splat-overload-test/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "splat-overload-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+splat-overload = { path = "../splat-overload" }

splat-overload-test/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

splat-overload-test/src/bin/multiple-args.rs

@@ -0,0 +1,23 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features, clippy::approx_constant)]
+
+use splat_overload::overload;
+
+overload! {
+    fn foo(x: i32, y: f64) {
+        println!("i32: {}, f64: {}", x, y);
+    }
+    fn foo(x: bool, y: i32, z: f64) {
+        println!("bool: {}, i32: {}, f64: {}", x, y, z);
+    }
+    fn foo(a: i32, b: f64, c: bool, d: u8) {
+        println!("i32: {}, f64: {}, bool: {}, u8: {}", a, b, c, d);
+    }
+}
+
+fn main() {
+    foo(42, 3.14);
+    foo(true, 42, 3.14);
+    foo(42, 3.14, true, 255);
+}

splat-overload-test/src/bin/multiple-mixed-args.rs

@@ -0,0 +1,27 @@
+#![feature(splat)]
+#![feature(tuple_trait)]
+#![allow(incomplete_features)]
+
+use splat_overload::overload;
+
+overload! {
+    fn calculate(a: i32, b: i32) {
+        println!("sum: {}", a + b);
+    }
+    fn calculate(a: f64, b: f64, c: f64) {
+        println!("average: {}", (a + b + c) / 3.0);
+    }
+    fn calculate(x: i32, y: i32, z: i32, w: i32) {
+        println!("product: {}", x * y * z * w);
+    }
+    fn calculate(a: f64, b: f64, c: f64, d: f64, e: f64) {
+        println!("max would need std: {} {} {} {} {}", a, b, c, d, e);
+    }
+}
+
+fn main() {
+    calculate(10, 20);
+    calculate(1.0, 2.0, 3.0);
+    calculate(2, 3, 4, 5);
+    calculate(1.0, 2.0, 3.0, 4.0, 5.0);
+}

splat-overload/Cargo.toml

@@ -1,4 +1,3 @@
-# Modify the workspace Cargo.toml instead of this file (if possible)
 [package]
 name = "splat-overload"
 version.workspace = true
@@ -11,6 +10,10 @@ readme.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 
+[lib]
+proc-macro = true
+
 [dependencies]
-# Delete this package and replace it with the actual dependencies
-example.workspace = true
+syn.workspace = true
+quote.workspace = true
+proc-macro2.workspace = true

splat-overload/src/lib.rs

@@ -1 +1,89 @@
-//! Delete this comment and add the actual code here
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    FnArg, ItemFn, Pat, Result,
+    parse::{Parse, ParseStream},
+    parse_macro_input,
+};
+
+struct OverloadInput {
+    functions: Vec<ItemFn>,
+}
+
+impl Parse for OverloadInput {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut functions = Vec::new();
+        while !input.is_empty() {
+            functions.push(input.parse::<ItemFn>()?);
+        }
+        Ok(OverloadInput { functions })
+    }
+}
+
+#[proc_macro]
+pub fn overload(input: TokenStream) -> TokenStream {
+    let OverloadInput { functions } = parse_macro_input!(input as OverloadInput);
+
+    let fn_name = &functions[0].sig.ident;
+
+    let trait_name = quote::format_ident!(
+        "{}Args",
+        fn_name
+            .to_string()
+            .chars()
+            .enumerate()
+            .map(|(i, c)| if i == 0 {
+                c.to_uppercase().next().unwrap()
+            } else {
+                c
+            })
+            .collect::<String>()
+    );
+
+    let mut impls = Vec::new();
+    for func in &functions {
+        // Collect All arguments and names
+        let mut arg_types = Vec::new();
+        let mut arg_names = Vec::new();
+        let mut arg_indices = Vec::new();
+        let block = &func.block;
+        for (i, arg) in func.sig.inputs.iter().enumerate() {
+            if let FnArg::Typed(pat_type) = arg {
+                let ty = &pat_type.ty;
+                arg_types.push(quote! { #ty });
+
+                let arg_name = if let Pat::Ident(pat_ident) = &*pat_type.pat {
+                    let ident = &pat_ident.ident;
+                    quote! { #ident }
+                } else {
+                    quote! { _arg }
+                };
+                arg_names.push(arg_name);
+
+                let index = syn::Index::from(i);
+                arg_indices.push(quote! { self.#index });
+            }
+        }
+        impls.push(quote! {
+            impl #trait_name for (#(#arg_types),*,) {
+                fn call(self) {
+                    #(let #arg_names = #arg_indices;)*
+                    #block
+                }
+            }
+        });
+    }
+    let generated = quote! {
+        trait #trait_name: std::marker::Tuple {
+            fn call(self);
+        }
+
+        #(#impls)*
+
+        fn #fn_name<T: #trait_name>(#[splat] args: T) {
+            args.call()
+        }
+    };
+
+    generated.into()
+}