Allow function aliases

demo-cxx/demo.cc

@@ -9,10 +9,18 @@ ThingC::ThingC(std::string appname) : appname(std::move(appname)) {}
 
 ThingC::~ThingC() { std::cout << "done with ThingC" << std::endl; }
 
+void ThingC::camelCaseMethod() const { std::cout << "camelCaseMethod" << std::endl; }
+void ThingC::overloadedMethod(int x) const { std::cout << "overloadedMethod: int x = " << x << std::endl; }
+void ThingC::overloadedMethod(float x) const { std::cout << "overloadedMethod: float x = " << x << std::endl; }
+
 std::unique_ptr<ThingC> make_demo(rust::Str appname) {
   return std::make_unique<ThingC>(std::string(appname));
 }
 
+void camelCaseFunction() { std::cout << "camelCaseFunction" << std::endl; }
+void overloadedFunction(int x) { std::cout << "overloadedFunction: int x = " << x << std::endl; }
+void overloadedFunction(float x) { std::cout << "overloadedFunction: float x = " << x << std::endl; }
+
 const std::string &get_name(const ThingC &thing) { return thing.appname; }
 
 void do_thing(SharedThing state) { print_r(*state.y); }

demo-cxx/demo.h

@@ -11,11 +11,18 @@ class ThingC {
   ThingC(std::string appname);
   ~ThingC();
 
+  void camelCaseMethod() const;
+  void overloadedMethod(int x) const;
+  void overloadedMethod(float x) const;
+
   std::string appname;
 };
 
 struct SharedThing;
 
+void camelCaseFunction();
+void overloadedFunction(int x);
+void overloadedFunction(float x);
 std::unique_ptr<ThingC> make_demo(rust::Str appname);
 const std::string &get_name(const ThingC &thing);
 void do_thing(SharedThing state);

demo-rs/src/main.rs

@@ -10,6 +10,18 @@ mod ffi {
         include!("demo-cxx/demo.h");
 
         type ThingC;
+        #[alias(snake_case_method)]
+        fn camelCaseMethod(&self);
+        #[alias(snake_case_function)]
+        fn camelCaseFunction();
+        #[alias(i32_method)]
+        fn overloadedMethod(&self, x: i32);
+        #[alias(f32_method)]
+        fn overloadedMethod(&self, x: f32);
+        #[alias(i32_function)]
+        fn overloadedFunction(x: i32);
+        #[alias(f32_function)]
+        fn overloadedFunction(x: f32);
         fn make_demo(appname: &str) -> UniquePtr<ThingC>;
         fn get_name(thing: &ThingC) -> &CxxString;
         fn do_thing(state: SharedThing);
@@ -30,7 +42,14 @@ fn print_r(r: &ThingR) {
 fn main() {
     let x = ffi::make_demo("demo of cxx::bridge");
     println!("this is a {}", ffi::get_name(x.as_ref().unwrap()));
-
+
+    x.snake_case_method();
+    ffi::snake_case_function();
+    x.i32_method(10);
+    x.f32_method(10.5);
+    ffi::i32_function(10);
+    ffi::f32_function(10.5);
+
     ffi::do_thing(ffi::SharedThing {
         z: 222,
         y: Box::new(ThingR(333)),

gen/src/write.rs

@@ -433,9 +433,10 @@ fn write_cxx_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
     writeln!(out, ") noexcept {{");
     write!(out, "  ");
     write_return_type(out, &efn.ret);
+    let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
     match &efn.receiver {
-        None => write!(out, "(*{}$)(", efn.ident),
-        Some(receiver) => write!(out, "({}::*{}$)(", receiver.ty, efn.ident),
+        None => write!(out, "(*{}$)(", ident),
+        Some(receiver) => write!(out, "({}::*{}$)(", receiver.ty, ident),
     }
     for (i, arg) in efn.args.iter().enumerate() {
         if i > 0 {
@@ -478,8 +479,8 @@ fn write_cxx_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
         _ => {}
     }
     match &efn.receiver {
-        None => write!(out, "{}$(", efn.ident),
-        Some(_) => write!(out, "(self.*{}$)(", efn.ident),
+        None => write!(out, "{}$(", ident),
+        Some(_) => write!(out, "(self.*{}$)(", ident),
     }
     for (i, arg) in efn.args.iter().enumerate() {
         if i > 0 {
@@ -612,9 +613,10 @@ fn write_rust_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
     for line in efn.doc.to_string().lines() {
         writeln!(out, "//{}", line);
     }
+    let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
     let local_name = match &efn.sig.receiver {
-        None => efn.ident.to_string(),
-        Some(receiver) => format!("{}::{}", receiver.ty, efn.ident),
+        None => ident.to_string(),
+        Some(receiver) => format!("{}::{}", receiver.ty, ident),
     };
     let invoke = mangle::extern_fn(&out.namespace, efn);
     let indirect_call = false;

macro/src/expand.rs

@@ -185,7 +185,7 @@ fn expand_cxx_type(namespace: &Namespace, ety: &ExternType) -> TokenStream {
 }
 
 fn expand_cxx_function_decl(namespace: &Namespace, efn: &ExternFn, types: &Types) -> TokenStream {
-    let ident = &efn.ident;
+    let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
     let receiver = efn.receiver.iter().map(|receiver| {
         let receiver_type = receiver.ty();
         quote!(_: #receiver_type)
@@ -225,7 +225,7 @@ fn expand_cxx_function_decl(namespace: &Namespace, efn: &ExternFn, types: &Types
 }
 
 fn expand_cxx_function_shim(namespace: &Namespace, efn: &ExternFn, types: &Types) -> TokenStream {
-    let ident = &efn.ident;
+    let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
     let doc = &efn.doc;
     let decl = expand_cxx_function_decl(namespace, efn, types);
     let receiver = efn.receiver.iter().map(|receiver| {
@@ -394,7 +394,8 @@ fn expand_function_pointer_trampoline(
     let c_trampoline = mangle::c_trampoline(namespace, efn, var);
     let r_trampoline = mangle::r_trampoline(namespace, efn, var);
     let local_name = parse_quote!(__);
-    let catch_unwind_label = format!("::{}::{}", efn.ident, var);
+    let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
+    let catch_unwind_label = format!("::{}::{}", ident, var);
     let shim = expand_rust_function_shim_impl(
         sig,
         types,

syntax/attrs.rs

@@ -10,6 +10,7 @@ pub struct Parser<'a> {
     pub doc: Option<&'a mut Doc>,
     pub derives: Option<&'a mut Vec<Derive>>,
     pub repr: Option<&'a mut Option<Atom>>,
+    pub alias: Option<&'a mut Option<Ident>>,
 }
 
 pub(super) fn parse_doc(cx: &mut Errors, attrs: &[Attribute]) -> Doc {
@@ -57,8 +58,19 @@ pub(super) fn parse(cx: &mut Errors, attrs: &[Attribute], mut parser: Parser) {
                 }
                 Err(err) => return cx.push(err),
             }
+        } else if attr.path.is_ident("alias") {
+            match attr.parse_args_with(|input: ParseStream| input.parse()) {
+                Ok(alias) => {
+                    if let Some(a) = &mut parser.alias {
+                        **a = Some(alias);
+                        continue;
+                    }
+                }
+                Err(err) => return cx.push(err),
+            }
+        } else {
+            return cx.error(attr, "unsupported attribute");
         }
-        return cx.error(attr, "unsupported attribute");
     }
 }
 

syntax/ident.rs

@@ -37,7 +37,8 @@ pub(crate) fn check_all(cx: &mut Check, namespace: &Namespace, apis: &[Api]) {
                 check(cx, &ety.ident);
             }
             Api::CxxFunction(efn) | Api::RustFunction(efn) => {
-                check(cx, &efn.ident);
+                let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
+                check(cx, ident);
                 for arg in &efn.args {
                     check(cx, &arg.ident);
                 }

syntax/mangle.rs

@@ -12,9 +12,10 @@ macro_rules! join {
 }
 
 pub fn extern_fn(namespace: &Namespace, efn: &ExternFn) -> Symbol {
+    let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
     match &efn.receiver {
-        Some(receiver) => join!(namespace, CXXBRIDGE, receiver.ty, efn.ident),
-        None => join!(namespace, CXXBRIDGE, efn.ident),
+        Some(receiver) => join!(namespace, CXXBRIDGE, receiver.ty, ident),
+        None => join!(namespace, CXXBRIDGE, ident),
     }
 }
 

syntax/mod.rs

@@ -70,6 +70,7 @@ pub struct ExternFn {
     pub lang: Lang,
     pub doc: Doc,
     pub ident: Ident,
+    pub alias: Option<Ident>,
     pub sig: Signature,
     pub semi_token: Token![;],
 }

syntax/parse.rs

@@ -327,6 +327,10 @@ fn parse_extern_fn(cx: &mut Errors, foreign_fn: &ForeignItemFn, lang: Lang) -> R
     let doc = attrs::parse_doc(cx, &foreign_fn.attrs);
     let fn_token = foreign_fn.sig.fn_token;
     let ident = foreign_fn.sig.ident.clone();
+    let mut alias = None;
+    if let Lang::Cxx = lang {
+        attrs::parse(cx, &foreign_fn.attrs, attrs::Parser { alias: Some(&mut alias), ..Default::default() });
+    }
     let paren_token = foreign_fn.sig.paren_token;
     let semi_token = foreign_fn.semi_token;
     let api_function = match lang {
@@ -338,6 +342,7 @@ fn parse_extern_fn(cx: &mut Errors, foreign_fn: &ForeignItemFn, lang: Lang) -> R
         lang,
         doc,
         ident,
+        alias,
         sig: Signature {
             fn_token,
             receiver,

syntax/types.rs

@@ -87,7 +87,7 @@ impl<'a> Types<'a> {
                     rust.insert(ident);
                 }
                 Api::CxxFunction(efn) | Api::RustFunction(efn) => {
-                    let ident = &efn.ident;
+                    let ident = if let Some(alias) = &efn.alias { alias } else { &efn.ident };
                     if !function_names.insert((&efn.receiver, ident)) {
                         duplicate_name(cx, efn, ident);
                     }