Add "return_type()" to Constructor

uniffi_bindgen/src/interface/function.rs

@@ -249,6 +249,42 @@ impl APIConverter<Argument> for weedle::argument::SingleArgument<'_> {
  }
 }
 
+/// Implemented by function-like types (Function, Method, Constructor)
+pub trait Callable {
+ fn arguments(&self) -> Vec<&Argument>;
+ fn return_type(&self) -> Option<Type>;
+ fn throws_type(&self) -> Option<Type>;
+}
+
+impl Callable for Function {
+ fn arguments(&self) -> Vec<&Argument> {
+ self.arguments()
+ }
+
+ fn return_type(&self) -> Option<Type> {
+ self.return_type().cloned()
+ }
+
+ fn throws_type(&self) -> Option<Type> {
+ self.throws_type()
+ }
+}
+
+// Needed because Askama likes to add extra refs to variables
+impl<T: Callable> Callable for &T {
+ fn arguments(&self) -> Vec<&Argument> {
+ (*self).arguments()
+ }
+
+ fn return_type(&self) -> Option<Type> {
+ (*self).return_type()
+ }
+
+ fn throws_type(&self) -> Option<Type> {
+ (*self).throws_type()
+ }
+}
+
 #[cfg(test)]
 mod test {
  use super::*;

uniffi_bindgen/src/interface/mod.rs

@@ -64,7 +64,7 @@ pub use enum_::Enum;
 mod error;
 pub use error::Error;
 mod function;
-pub use function::{Argument, Function};
+pub use function::{Argument, Callable, Function};
 mod literal;
 pub use literal::{Literal, Radix};
 mod namespace;

uniffi_bindgen/src/interface/object.rs

@@ -65,7 +65,7 @@ use uniffi_meta::Checksum;
 
 use super::attributes::{Attribute, ConstructorAttributes, InterfaceAttributes, MethodAttributes};
 use super::ffi::{FfiArgument, FfiFunction, FfiType};
-use super::function::Argument;
+use super::function::{Argument, Callable};
 use super::types::{Type, TypeIterator};
 use super::{convert_type, APIConverter, ComponentInterface};
 
@@ -248,6 +248,7 @@ pub struct Constructor {
  // avoids a weird circular dependency in the calculation.
  #[checksum_ignore]
  pub(super) ffi_func: FfiFunction,
+ pub(super) return_type: Option<Type>,
  pub(super) attributes: ConstructorAttributes,
 }
 
@@ -268,6 +269,10 @@ impl Constructor {
  &self.ffi_func
  }
 
+ pub fn return_type(&self) -> Option<&Type> {
+ self.return_type.as_ref()
+ }
+
  pub fn throws(&self) -> bool {
  self.attributes.get_throws_err().is_some()
  }
@@ -290,6 +295,9 @@ impl Constructor {
  self.ffi_func.name = format!("{ci_prefix}_{obj_name}_{}", self.name);
  self.ffi_func.arguments = self.arguments.iter().map(Into::into).collect();
  self.ffi_func.return_type = Some(FfiType::RustArcPtr(obj_name.to_string()));
+
+ // this is a bit of a dirty place to put this, but there isn't another "general" pass
+ self.return_type = Some(Type::Object(obj_name.to_string()));
  }
 
  pub fn iter_types(&self) -> TypeIterator<'_> {
@@ -302,6 +310,7 @@ impl Default for Constructor {
  Constructor {
  name: String::from("new"),
  arguments: Vec::new(),
+ return_type: None,
  ffi_func: Default::default(),
  attributes: Default::default(),
  }
@@ -317,12 +326,27 @@ impl APIConverter<Constructor> for weedle::interface::ConstructorInterfaceMember
  Ok(Constructor {
  name: String::from(attributes.get_name().unwrap_or("new")),
  arguments: self.args.body.list.convert(ci)?,
+ return_type: None,
  ffi_func: Default::default(),
  attributes,
  })
  }
 }
 
+impl Callable for Constructor {
+ fn arguments(&self) -> Vec<&Argument> {
+ self.arguments()
+ }
+
+ fn return_type(&self) -> Option<Type> {
+ self.return_type().cloned()
+ }
+
+ fn throws_type(&self) -> Option<Type> {
+ self.throws_type()
+ }
+}
+
 // Represents an instance method for an object type.
 //
 // The FFI will represent this as a function whose first/self argument is a
@@ -479,6 +503,20 @@ impl APIConverter<Method> for weedle::interface::OperationInterfaceMember<'_> {
  }
 }
 
+impl Callable for Method {
+ fn arguments(&self) -> Vec<&Argument> {
+ self.arguments()
+ }
+
+ fn return_type(&self) -> Option<Type> {
+ self.return_type().cloned()
+ }
+
+ fn throws_type(&self) -> Option<Type> {
+ self.throws_type()
+ }
+}
+
 #[cfg(test)]
 mod test {
  use super::*;