Adding UDL async support

mozilla · Nov 6, 2023 · 6a25f90 · 6a25f90
1 parent 9db16c5
commit 6a25f90
Show file tree

Hide file tree

Showing 9 changed files with 73 additions and 18 deletions.
diff --git a/docs/manual/src/futures.md b/docs/manual/src/futures.md
@@ -4,8 +4,6 @@ UniFFI supports exposing async Rust functions over the FFI. It can convert a Rus
 
 Check out the [examples](https://github.com/mozilla/uniffi-rs/tree/main/examples/futures) or the more terse and thorough [fixtures](https://github.com/mozilla/uniffi-rs/tree/main/fixtures/futures).
 
-Note that currently async functions are only supported by proc-macros, UDL support is being planned in https://github.com/mozilla/uniffi-rs/issues/1716.
-
 ## Example
 
 This is a short "async sleep()" example:
@@ -34,6 +32,14 @@ if __name__ == '__main__':
     asyncio.run(main())
 ```
 
+Async functions can also be defined in UDL:
+```idl
+namespace example {
+    [Async]
+    string say_after(u64 ms, string who);
+}
+```
+
 This code uses `asyncio` to drive the future to completion, while our exposed function is used with `await`.
 
 In Rust `Future` terminology this means the foreign bindings supply the "executor" - think event-loop, or async runtime. In this example it's `asyncio`. There's no requirement for a Rust event loop.

diff --git a/docs/manual/src/udl/functions.md b/docs/manual/src/udl/functions.md
@@ -47,3 +47,16 @@ fun helloName(name: String = "world" ): String {
     // ...
 }
 ```
+
+## Async
+
+Async functions can be exposed using the `[Async]` attribute:
+
+```idl
+namespace Example {
+    [Async]
+    string async_hello();
+}
+```
+
+See the [Async/Future support section](../futures.md) for details.
diff --git a/fixtures/futures/src/futures.udl b/fixtures/futures/src/futures.udl
@@ -1 +1,4 @@
-namespace futures {};
+namespace futures {
+    [Async]
+    boolean always_ready();
+};
diff --git a/fixtures/futures/src/lib.rs b/fixtures/futures/src/lib.rs
@@ -67,8 +67,9 @@ pub fn greet(who: String) -> String {
     format!("Hello, {who}")
 }
 
-/// Async function that is immediatly ready.
-#[uniffi::export]
+/// Async function that is immediately ready.
+///
+/// (This one is defined in the UDL to test UDL support)
 pub async fn always_ready() -> bool {
     true
 }

diff --git a/fixtures/futures/src/uniffi_futures.udl b/fixtures/futures/src/uniffi_futures.udl
diff --git a/uniffi_bindgen/src/scaffolding/templates/ObjectTemplate.rs b/uniffi_bindgen/src/scaffolding/templates/ObjectTemplate.rs
@@ -15,7 +15,7 @@
 #[::uniffi::export_for_udl]
 pub trait r#{{ obj.name() }} {
     {%- for meth in obj.methods() %}
-    fn {{ meth.name() }}(
+    fn {% if meth.is_async() %}async {% endif %}{{ meth.name() }}(
         {% if meth.takes_self_by_arc()%}self: Arc<Self>{% else %}&self{% endif %},
         {%- for arg in meth.arguments() %}
         {{ arg.name() }}: {% if arg.by_ref() %}&{% endif %}{{ arg.as_type().borrow()|type_rs }},
@@ -68,7 +68,7 @@ impl {{ obj.rust_name() }} {
 {%- for meth in obj.methods() %}
 #[::uniffi::export_for_udl]
 impl {{ obj.rust_name() }} {
-    pub fn r#{{ meth.name() }}(
+    pub {% if meth.is_async() %}async {% endif %}fn r#{{ meth.name() }}(
         {% if meth.takes_self_by_arc()%}self: Arc<Self>{% else %}&self{% endif %},
         {%- for arg in meth.arguments() %}
         r#{{ arg.name() }}: {% if arg.by_ref() %}&{% endif %}{{ arg.as_type().borrow()|type_rs }},

diff --git a/uniffi_bindgen/src/scaffolding/templates/TopLevelFunctionTemplate.rs b/uniffi_bindgen/src/scaffolding/templates/TopLevelFunctionTemplate.rs
@@ -1,5 +1,5 @@
 #[::uniffi::export_for_udl]
-pub fn r#{{ func.name() }}(
+pub {% if func.is_async() %}async {% endif %}fn r#{{ func.name() }}(
     {%- for arg in func.arguments() %}
     r#{{ arg.name() }}: {% if arg.by_ref() %}&{% endif %}{{ arg.as_type().borrow()|type_rs }},
     {%- endfor %}

diff --git a/uniffi_udl/src/attributes.rs b/uniffi_udl/src/attributes.rs
@@ -41,6 +41,7 @@ pub(super) enum Attribute {
     Custom,
     // The interface described is implemented as a trait.
     Trait,
+    Async,
 }
 
 impl Attribute {
@@ -67,6 +68,7 @@ impl TryFrom<&weedle::attribute::ExtendedAttribute<'_>> for Attribute {
                 "Error" => Ok(Attribute::Error),
                 "Custom" => Ok(Attribute::Custom),
                 "Trait" => Ok(Attribute::Trait),
+                "Async" => Ok(Attribute::Async),
                 _ => anyhow::bail!("ExtendedAttributeNoArgs not supported: {:?}", (attr.0).0),
             },
             // Matches assignment-style attributes like ["Throws=Error"]
@@ -196,8 +198,9 @@ impl<T: TryInto<EnumAttributes, Error = anyhow::Error>> TryFrom<Option<T>> for E
 
 /// Represents UDL attributes that might appear on a function.
 ///
-/// This supports the `[Throws=ErrorName]` attribute for functions that
-/// can produce an error.
+/// This supports:
+///   * `[Throws=ErrorName]` attribute for functions that can produce an error.
+///   * `[Async] for async functions
 #[derive(Debug, Clone, Checksum, Default)]
 pub(super) struct FunctionAttributes(Vec<Attribute>);
 
@@ -210,6 +213,10 @@ impl FunctionAttributes {
             _ => None,
         })
     }
+
+    pub(super) fn is_async(&self) -> bool {
+        self.0.iter().any(|attr| matches!(attr, Attribute::Async))
+    }
 }
 
 impl FromIterator<Attribute> for FunctionAttributes {
@@ -224,7 +231,7 @@ impl TryFrom<&weedle::attribute::ExtendedAttributeList<'_>> for FunctionAttribut
         weedle_attributes: &weedle::attribute::ExtendedAttributeList<'_>,
     ) -> Result<Self, Self::Error> {
         let attrs = parse_attributes(weedle_attributes, |attr| match attr {
-            Attribute::Throws(_) => Ok(()),
+            Attribute::Throws(_) | Attribute::Async => Ok(()),
             _ => bail!(format!("{attr:?} not supported for functions")),
         })?;
         Ok(Self(attrs))
@@ -406,6 +413,10 @@ impl MethodAttributes {
         })
     }
 
+    pub(super) fn is_async(&self) -> bool {
+        self.0.iter().any(|attr| matches!(attr, Attribute::Async))
+    }
+
     pub(super) fn get_self_by_arc(&self) -> bool {
         self.0
             .iter()
@@ -425,8 +436,7 @@ impl TryFrom<&weedle::attribute::ExtendedAttributeList<'_>> for MethodAttributes
         weedle_attributes: &weedle::attribute::ExtendedAttributeList<'_>,
     ) -> Result<Self, Self::Error> {
         let attrs = parse_attributes(weedle_attributes, |attr| match attr {
-            Attribute::SelfType(_) => Ok(()),
-            Attribute::Throws(_) => Ok(()),
+            Attribute::SelfType(_) | Attribute::Throws(_) | Attribute::Async => Ok(()),
             _ => bail!(format!("{attr:?} not supported for methods")),
         })?;
         Ok(Self(attrs))
@@ -641,14 +651,22 @@ mod test {
     }
 
     #[test]
-    fn test_throws_attribute() {
+    fn test_function_attributes() {
         let (_, node) = weedle::attribute::ExtendedAttributeList::parse("[Throws=Error]").unwrap();
         let attrs = FunctionAttributes::try_from(&node).unwrap();
         assert!(matches!(attrs.get_throws_err(), Some("Error")));
+        assert!(!attrs.is_async());
 
         let (_, node) = weedle::attribute::ExtendedAttributeList::parse("[]").unwrap();
         let attrs = FunctionAttributes::try_from(&node).unwrap();
         assert!(attrs.get_throws_err().is_none());
+        assert!(!attrs.is_async());
+
+        let (_, node) =
+            weedle::attribute::ExtendedAttributeList::parse("[Throws=Error, Async]").unwrap();
+        let attrs = FunctionAttributes::try_from(&node).unwrap();
+        assert!(matches!(attrs.get_throws_err(), Some("Error")));
+        assert!(attrs.is_async());
     }
 
     #[test]
@@ -673,22 +691,34 @@ mod test {
         let attrs = MethodAttributes::try_from(&node).unwrap();
         assert!(!attrs.get_self_by_arc());
         assert!(matches!(attrs.get_throws_err(), Some("Error")));
+        assert!(!attrs.is_async());
 
         let (_, node) = weedle::attribute::ExtendedAttributeList::parse("[]").unwrap();
         let attrs = MethodAttributes::try_from(&node).unwrap();
         assert!(!attrs.get_self_by_arc());
         assert!(attrs.get_throws_err().is_none());
+        assert!(!attrs.is_async());
 
         let (_, node) =
             weedle::attribute::ExtendedAttributeList::parse("[Self=ByArc, Throws=Error]").unwrap();
         let attrs = MethodAttributes::try_from(&node).unwrap();
         assert!(attrs.get_self_by_arc());
         assert!(attrs.get_throws_err().is_some());
+        assert!(!attrs.is_async());
+
+        let (_, node) =
+            weedle::attribute::ExtendedAttributeList::parse("[Self=ByArc, Throws=Error, Async]")
+                .unwrap();
+        let attrs = MethodAttributes::try_from(&node).unwrap();
+        assert!(attrs.get_self_by_arc());
+        assert!(attrs.get_throws_err().is_some());
+        assert!(attrs.is_async());
 
         let (_, node) = weedle::attribute::ExtendedAttributeList::parse("[Self=ByArc]").unwrap();
         let attrs = MethodAttributes::try_from(&node).unwrap();
         assert!(attrs.get_self_by_arc());
         assert!(attrs.get_throws_err().is_none());
+        assert!(!attrs.is_async());
     }
 
     #[test]

diff --git a/uniffi_udl/src/converters/callables.rs b/uniffi_udl/src/converters/callables.rs
@@ -89,6 +89,7 @@ impl APIConverter<FnMetadata> for weedle::namespace::OperationNamespaceMember<'_
             Some(id) => id.0.to_string(),
         };
         let attrs = FunctionAttributes::try_from(self.attributes.as_ref())?;
+        let is_async = attrs.is_async();
         let throws = match attrs.get_throws_err() {
             None => None,
             Some(name) => match ci.get_type(name) {
@@ -99,7 +100,7 @@ impl APIConverter<FnMetadata> for weedle::namespace::OperationNamespaceMember<'_
         Ok(FnMetadata {
             module_path: ci.module_path(),
             name,
-            is_async: false,
+            is_async,
             return_type,
             inputs: self.args.body.list.convert(ci)?,
             throws,
@@ -140,6 +141,7 @@ impl APIConverter<MethodMetadata> for weedle::interface::OperationInterfaceMembe
         }
         let return_type = ci.resolve_return_type_expression(&self.return_type)?;
         let attributes = MethodAttributes::try_from(self.attributes.as_ref())?;
+        let is_async = attributes.is_async();
 
         let throws = match attributes.get_throws_err() {
             Some(name) => match ci.get_type(name) {
@@ -164,7 +166,7 @@ impl APIConverter<MethodMetadata> for weedle::interface::OperationInterfaceMembe
             },
             // We don't know the name of the containing `Object` at this point, fill it in later.
             self_name: Default::default(),
-            is_async: false, // not supported in UDL
+            is_async,
             inputs: self.args.body.list.convert(ci)?,
             return_type,
             throws,
@@ -184,6 +186,7 @@ impl APIConverter<TraitMethodMetadata> for weedle::interface::OperationInterface
         }
         let return_type = ci.resolve_return_type_expression(&self.return_type)?;
         let attributes = MethodAttributes::try_from(self.attributes.as_ref())?;
+        let is_async = attributes.is_async();
 
         let throws = match attributes.get_throws_err() {
             Some(name) => match ci.get_type(name) {
@@ -208,7 +211,7 @@ impl APIConverter<TraitMethodMetadata> for weedle::interface::OperationInterface
                     name
                 }
             },
-            is_async: false, // not supported in udl
+            is_async,
             inputs: self.args.body.list.convert(ci)?,
             return_type,
             throws,