dtolnay · dtolnay · Apr 17, 2020 · Apr 7, 2020 · Apr 15, 2020 · Apr 15, 2020
diff --git a/Cargo.toml b/Cargo.toml
@@ -19,6 19,7 @@ anyhow = "1.0"
 cc = "1.0.49"
 codespan-reporting = "0.9"
 cxxbridge-macro = { version = "=0.2.9", path = "macro" }
 itertools = "0.9"
 link-cplusplus = "1.0"
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 quote = "1.0"

diff --git a/README.md b/README.md
@@ -84,8 84,10 @@ mod ffi {
 
  // Functions implemented in C .
  fn make_demo(appname: &str) -> UniquePtr<ThingC>;
- fn get_name(thing: &ThingC) -> &CxxString;
  fn do_thing(state: SharedThing);
 
  // Methods implemented in C .
  fn get_name(self: &ThingC) -> &CxxString;
  }
 
  extern "Rust" {
@@ -95,6 97,9 @@ mod ffi {
 
  // Functions implemented in Rust.
  fn print_r(r: &ThingR);
 
  // Methods implemented in Rust.
  fn print(self: &ThingR);
  }
 }
 ```
@@ -335,8 340,6 @@ This is still early days for CXX; I am releasing it as a minimum viable product
 to collect feedback on the direction and invite collaborators. Here are some of
 the facets that I still intend for this project to tackle:
 
-- [ ] Support associated methods: `extern "Rust" { fn f(self: &Struct); }`
-- [ ] Support C member functions
 - [ ] Support structs with type parameters
 - [ ] Support async functions
 

diff --git a/demo-cxx/demo.cc b/demo-cxx/demo.cc
@@ -9,13 9,19 @@ ThingC::ThingC(std::string appname) : appname(std::move(appname)) {}
 
 ThingC::~ThingC() { std::cout << "done with ThingC" << std::endl; }
 
 const std::string &ThingC::get_name() const {
  std::cout << "I'm a C method!" << std::endl;
  return this->appname;
 }
 
 std::unique_ptr<ThingC> make_demo(rust::Str appname) {
  return std::unique_ptr<ThingC>(new ThingC(std::string(appname)));
 }
 
-const std::string &get_name(const ThingC &thing) { return thing.appname; }
-
-void do_thing(SharedThing state) { print_r(*state.y); }
 void do_thing(SharedThing state) {
  print_r(*state.y);
  state.y->print();
 }
 
 } // namespace example
 } // namespace org
diff --git a/demo-cxx/demo.h b/demo-cxx/demo.h
@@ -12,12 12,13 @@ class ThingC {
  ~ThingC();
 
  std::string appname;
 
  const std::string &get_name() const;
 };
 
 struct SharedThing;
 
 std::unique_ptr<ThingC> make_demo(rust::Str appname);
-const std::string &get_name(const ThingC &thing);
 void do_thing(SharedThing state);
 
 } // namespace example

diff --git a/demo-rs/src/main.rs b/demo-rs/src/main.rs
@@ -11,13 11,15 @@ mod ffi {
 
  type ThingC;
  fn make_demo(appname: &str) -> UniquePtr<ThingC>;
- fn get_name(thing: &ThingC) -> &CxxString;
  fn get_name(self: &ThingC) -> &CxxString;
  fn do_thing(state: SharedThing);
 
  }
 
  extern "Rust" {
  type ThingR;
  fn print_r(r: &ThingR);
  fn print(self: &ThingR);
  }
 }
 
@@ -27,9 29,15 @@ fn print_r(r: &ThingR) {
  println!("called back with r={}", r.0);
 }
 
 impl ThingR {
  fn print(&self) {
  println!("method called back with r={}", self.0);
  }
 }
 
 fn main() {
  let x = ffi::make_demo("demo of cxx::bridge");
- println!("this is a {}", ffi::get_name(x.as_ref().unwrap()));
  println!("this is a {}", x.as_ref().unwrap().get_name());
 
  ffi::do_thing(ffi::SharedThing {
  z: 222,

diff --git a/gen/write.rs b/gen/write.rs
@@ -2,7 2,8 @@ use crate::gen::namespace::Namespace;
 use crate::gen::out::OutFile;
 use crate::gen::{include, Opt};
 use crate::syntax::atom::Atom::{self, *};
-use crate::syntax::{Api, ExternFn, Signature, Struct, Type, Types, Var};
 use crate::syntax::{Api, ExternFn, ExternType, Receiver, Signature, Struct, Type, Types, Var};
 use itertools::Itertools;
 use proc_macro2::Ident;
 
 pub(super) fn gen(
@@ -44,10 45,30 @@ pub(super) fn gen(
  }
  }
 
  let methods_for_type = apis.iter().filter_map(|api| match api {
  Api::RustFunction(efn) => match &efn.sig.receiver {
  Some(rcvr) => Some((&rcvr.ident, efn)),
  _ => None,
  },
  _ => None,
  }).into_group_map();
 
  for api in apis {
- if let Api::Struct(strct) = api {
- out.next_section();
- write_struct(out, strct);
  match api {
  Api::Struct(strct) => {
  out.next_section();
  write_struct(out, strct);
  }
  Api::RustType(ety) => {
  match methods_for_type.get(&ety.ident) {
  Some(methods) => {
  out.next_section();
  write_struct_with_methods(out, ety, methods);
  },
  _ => {}
  }
  }
  _ => {}
  }
  }
 
@@ -300,6 321,23 @@ fn write_struct_using(out: &mut OutFile, ident: &Ident) {
  writeln!(out, "using {} = {};", ident, ident);
 }
 
 fn write_struct_with_methods(out: &mut OutFile, ety: &ExternType, methods: &Vec<&ExternFn>) {
  for line in ety.doc.to_string().lines() {
  writeln!(out, "//{}", line);
  }
  writeln!(out, "struct {} final {{", ety.ident);
  writeln!(out, " {}() = delete;", ety.ident);
  writeln!(out, " {}(const {}&) = delete;", ety.ident, ety.ident);
  for method in methods {
  write!(out, " ");
  let sig = &method.sig;
  let local_name = method.ident.to_string();
  write_rust_function_shim_decl(out, &local_name, sig, None, false);
  writeln!(out, ";");
  }
  writeln!(out, "}};");
 }
 
 fn write_exception_glue(out: &mut OutFile, apis: &[Api]) {
  let mut has_cxx_throws = false;
  for api in apis {
@@ -326,9 364,16 @@ fn write_cxx_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
  } else {
  write_extern_return_type_space(out, &efn.ret, types);
  }
- write!(out, "{}cxxbridge02${}(", out.namespace, efn.ident);
  let receiver_type = match &efn.receiver {
  Some(base) => base.ident.to_string(),
  None => "_".to_string(),
  };
  write!(out, "{}cxxbridge02${}${}(", out.namespace, receiver_type, efn.ident);
  if let Some(base) = &efn.receiver {
  write!(out, "{} *__receiver$", base.ident);
  }
  for (i, arg) in efn.args.iter().enumerate() {
- if i > 0 {
  if i > 0 || efn.receiver.is_some() {
  write!(out, ", ");
  }
  if arg.ty == RustString {
@@ -347,14 392,27 @@ fn write_cxx_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
  writeln!(out, ") noexcept {{");
  write!(out, " ");
  write_return_type(out, &efn.ret);
- write!(out, "(*{}$)(", efn.ident);
  match &efn.receiver {
  None => write!(out, "(*{}$)(", efn.ident),
  Some(base) => write!(out, "({}::*{}$)(", base.ident, efn.ident),
  }
  for (i, arg) in efn.args.iter().enumerate() {
  if i > 0 {
  write!(out, ", ");
  }
  write_type(out, &arg.ty);
  }
- writeln!(out, ") = {};", efn.ident);
  write!(out, ")");
  match &efn.receiver {
  Some(Receiver { mutability: None, ident: _ }) => write!(out, " const"),
  _ => {},
  }
  write!(out, " = ");
  match &efn.receiver {
  None => write!(out, "{}", efn.ident),
  Some(base) => write!(out, "&{}::{}", base.ident, efn.ident),
  }
  writeln!(out, ";");
  write!(out, " ");
  if efn.throws {
  writeln!(out, "::rust::Str::Repr throw$;");
@@ -377,7 435,10 @@ fn write_cxx_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
  }
  _ => {}
  }
- write!(out, "{}$(", efn.ident);
  match &efn.receiver {
  None => write!(out, "{}$(", efn.ident),
  Some(_) => write!(out, "(__receiver$->*{}$)(", efn.ident),
  }
  for (i, arg) in efn.args.iter().enumerate() {
  if i > 0 {
  write!(out, ", ");
@@ -452,7 513,11 @@ fn write_function_pointer_trampoline(
 }
 
 fn write_rust_function_decl(out: &mut OutFile, efn: &ExternFn, types: &Types) {
- let link_name = format!("{}cxxbridge02${}", out.namespace, efn.ident);
  let receiver_type = match &efn.receiver {
  Some(base) => base.ident.to_string(),
  None => "_".to_string(),
  };
  let link_name = format!("{}cxxbridge02${}${}", out.namespace, receiver_type, efn.ident);
  let indirect_call = false;
  write_rust_function_decl_impl(out, &link_name, efn, types, indirect_call);
 }
@@ -471,6 536,10 @@ fn write_rust_function_decl_impl(
  }
  write!(out, "{}(", link_name);
  let mut needs_comma = false;
  if let Some(base) = &sig.receiver {
  write!(out, "{} &__receiver$", base.ident);
  needs_comma = true;
  }
  for arg in &sig.args {
  if needs_comma {
  write!(out, ", ");
@@ -500,20 569,26 @@ fn write_rust_function_shim(out: &mut OutFile, efn: &ExternFn, types: &Types) {
  writeln!(out, "//{}", line);
  }
  let local_name = efn.ident.to_string();
- let invoke = format!("{}cxxbridge02${}", out.namespace, efn.ident);
  let receiver_type = match &efn.receiver {
  Some(base) => base.ident.to_string(),
  None => "_".to_string(),
  };
  let invoke = format!("{}cxxbridge02${}${}", out.namespace, receiver_type, efn.ident);
  let indirect_call = false;
  write_rust_function_shim_impl(out, &local_name, efn, types, &invoke, indirect_call);
 }
 
-fn write_rust_function_shim_impl(
 fn write_rust_function_shim_decl(
  out: &mut OutFile,
  local_name: &str,
  sig: &Signature,
- types: &Types,
- invoke: &str,
  receiver: Option<&Receiver>,
  indirect_call: bool,
 ) {
  write_return_type(out, &sig.ret);
  if let Some(base) = receiver {
  write!(out, "{}::", base.ident);
  }
  write!(out, "{}(", local_name);
  for (i, arg) in sig.args.iter().enumerate() {
  if i > 0 {
@@ -532,6 607,21 @@ fn write_rust_function_shim_impl(
  if !sig.throws {
  write!(out, " noexcept");
  }
 }
 
 fn write_rust_function_shim_impl(
  out: &mut OutFile,
  local_name: &str,
  sig: &Signature,
  types: &Types,
  invoke: &str,
  indirect_call: bool,
 ) {
  if out.header && sig.receiver.is_some() {
  // We've already defined this inside the struct.
  return;
  }
  write_rust_function_shim_decl(out, local_name, sig, sig.receiver.as_ref(), indirect_call);
  if out.header {
  writeln!(out, ";");
  } else {
@@ -570,8 660,11 @@ fn write_rust_function_shim_impl(
  write!(out, "::rust::Str::Repr error$ = ");
  }
  write!(out, "{}(", invoke);
  if let Some(_) = &sig.receiver {
  write!(out, "*this");
  }
  for (i, arg) in sig.args.iter().enumerate() {
- if i > 0 {
  if i > 0 || sig.receiver.is_some() {
  write!(out, ", ");
  }
  match &arg.ty {