feat: Implement our own Future API in Python, and continue the Rust…

… side.

uniffi/src/ffi/ffifuture.rs

@@ -1,7 +1,10 @@
 use super::FfiDefault;
 use std::{
     future::{self, Future},
+    mem::{self, ManuallyDrop},
     pin::Pin,
+    sync::Arc,
+    task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
 };
 
 #[repr(transparent)]
@@ -19,6 +22,16 @@ where
     {
         Self(Box::pin(future))
     }
+
+    pub fn poll(&mut self, waker_pointer: usize) -> Option<T> {
+        let waker: Waker = { unimplemented!() };
+        let context: Context = Context::from_waker(&waker);
+
+        match Pin::new(&mut self.0).poll(&mut context) {
+            Poll::Ready(result) => Some(result),
+            Poll::Pending => None,
+        }
+    }
 }
 
 impl<T> FfiDefault for FfiFuture<T>
@@ -29,3 +42,40 @@ where
         Self::new(future::ready(T::ffi_default()))
     }
 }
+
+struct FfiTaskWakerBuilder<F>(F)
+where
+    F: Fn() + Send + Sync + 'static;
+
+impl<F> FfiTaskWakerBuilder<F>
+where
+    F: Fn() + Send + Sync + 'static,
+{
+    const VTABLE: RawWakerVTable = RawWakerVTable::new(
+        Self::clone_waker,
+        Self::wake,
+        Self::wake_by_ref,
+        Self::drop_waker,
+    );
+
+    unsafe fn clone_waker(ptr: *const ()) -> RawWaker {
+        let arc = ManuallyDrop::new(Arc::from_raw(ptr as *const F));
+        mem::forget(arc.clone());
+
+        RawWaker::new(ptr, &Self::VTABLE)
+    }
+
+    unsafe fn wake(ptr: *const ()) {
+        let arc = Arc::from_raw(ptr as *const F);
+        (arc)();
+    }
+
+    unsafe fn wake_by_ref(ptr: *const ()) {
+        let arc = ManuallyDrop::new(Arc::from_raw(ptr as *const F));
+        (arc)();
+    }
+
+    unsafe fn drop_waker(ptr: *const ()) {
+        drop(Arc::from_raw(ptr as *const F));
+    }
+}

uniffi_bindgen/src/bindings/python/templates/FutureTemplate.py

@@ -0,0 +1,93 @@
+class FfiFuture(ctypes.Structure):
+    _fields_ = [
+        ("waker", ctypes.c_uint32),
+    ]
+
+class FuturePoll(enum.Enum):
+    PENDING = 0
+    DONE = 1
+
+class Future:
+    def __init__(self, future: any):
+        self._asyncio_future_blocking = False
+        self._loop = asyncio.get_event_loop()
+        self._state = FuturePoll.PENDING
+        self._result = None
+        self._future = future
+        self._waker = None
+        self._callbacks = []
+
+        def poll():
+            state, self._result = (self._future)()
+
+            if state == FuturePoll.DONE:
+                self.set_result(self._result)
+                self._state = state
+
+        self._waker = poll
+
+        # Poll it once.
+        (self._future_waker())()
+
+    def _future_waker(self) -> any:
+        return self._waker
+
+    def done(self) -> bool:
+        return self._state == FuturePoll.DONE
+
+    def result(self) -> any:
+        if self._state != FuturePoll.DONE:
+            raise RuntimeError('Result is not ready')
+
+        return self._result
+
+    def set_result(self, result: any):
+        if self._state != FuturePoll.PENDING:
+            raise RuntimeError('This future has already been resolved')
+
+        self._result = result
+        self._state = FuturePoll.DONE
+        self.__schedule_callbacks()
+
+    def __schedule_callbacks(self):
+        callbacks = self._callbacks[:]
+
+        if not callbacks:
+            return
+
+        self._callbacks[:] = []
+
+        for callback, context in callbacks:
+            self._loop.call_soon(callback, self, context=context)
+
+    def add_done_callback(self, fn, *, context=None):
+        if self._state != FuturePoll.PENDING:
+            self._loop.call_soon(fn, self, context=context)
+        else:
+            if context is None:
+                context = contextvars.copy_context()
+
+            self._callbacks.append((fn, context))
+
+    def remove_done_callback(self, fn):
+        filtered_callbacks = [(callback, context)
+                              for (callback, context) in self._callbacks
+                              if callback != fn]
+        removed_count = len(self._callbacks) - len(filtered_callbacks)
+
+        if removed_count:
+            self._callbacks[:] = filtered_callbacks
+
+        return removed_count
+
+    def __await__(self):
+        if not self.done():
+            self._asyncio_future_blocking = True
+            yield self
+
+        if not self.done():
+            raise RuntimeError('await wasn\'t used with future')
+
+        return self.result()
+
+    __iter__ = __await__

uniffi_bindgen/src/bindings/python/templates/NamespaceLibraryTemplate.py

@@ -32,8 +32,20 @@ def loadIndirect():
 
 _UniFFILib = loadIndirect()
 {%- for func in ci.iter_ffi_function_definitions() %}
+{%- if func.is_async() %}
+
+# ASYNC
+_UniFFILib.{{ func.name() }}.argtypes = (
+    {%- call py::arg_list_ffi_decl(func) -%}
+)
+_UniFFILib.{{ func.name() }}.restype = {% match func.return_type() %}{% when Some with (type_) %}FfiFuture{% when None %}None{% endmatch %}
+
+{%- else %}
+
 _UniFFILib.{{ func.name() }}.argtypes = (
     {%- call py::arg_list_ffi_decl(func) -%}
 )
 _UniFFILib.{{ func.name() }}.restype = {% match func.return_type() %}{% when Some with (type_) %}{{ type_|ffi_type_name }}{% when None %}None{% endmatch %}
+
+{%- endif %}
 {%- endfor %}

uniffi_bindgen/src/bindings/python/templates/TopLevelFunctionTemplate.py

@@ -4,7 +4,14 @@
 
 async def {{ func.name()|fn_name }}({%- call py::arg_list_decl(func) -%}):
     {%- call py::setup_args(func) %}
-    return {{ return_type|lift_fn }}({% call py::to_ffi_call(func) %})
+    def inner() -> (FuturePoll, any):
+        # return {{ return_type|lift_fn }}({% call py::to_ffi_call(func) %})
+        pass
+
+    future = Future(inner)
+    # waker = future._future_waker()
+
+    await future
 
 {%- else %}
 

uniffi_bindgen/src/bindings/python/templates/wrapper.py

@@ -25,6 +25,7 @@
 import contextlib
 import datetime
 import asyncio
+import enum
 {%- for module_name in self.imports() %}
 import {{ module_name }}
 {%- endfor %}
@@ -35,6 +36,7 @@
 {% include "RustBufferTemplate.py" %}
 {% include "Helpers.py" %}
 {% include "RustBufferHelper.py" %}
+{% include "FutureTemplate.py" %}
 
 # Contains loading, initialization code,
 # and the FFI Function declarations in a com.sun.jna.Library.

uniffi_bindgen/src/interface/ffi.rs

@@ -59,6 +59,7 @@ pub enum FFIType {
 #[derive(Debug, Default, Clone)]
 pub struct FFIFunction {
     pub(super) name: String,
+    pub(super) is_async: bool,
     pub(super) arguments: Vec<FFIArgument>,
     pub(super) return_type: Option<FFIType>,
 }
@@ -67,9 +68,15 @@ impl FFIFunction {
     pub fn name(&self) -> &str {
         &self.name
     }
+
+    pub fn is_async(&self) -> bool {
+        self.is_async
+    }
+
     pub fn arguments(&self) -> Vec<&FFIArgument> {
         self.arguments.iter().collect()
     }
+
     pub fn return_type(&self) -> Option<&FFIType> {
         self.return_type.as_ref()
     }

uniffi_bindgen/src/interface/function.rs

@@ -134,6 +134,7 @@ impl From<uniffi_meta::FnMetadata> for Function {
 
         let ffi_func = FFIFunction {
             name: ffi_name,
+            is_async,
             ..FFIFunction::default()
         };
 

uniffi_bindgen/src/interface/mod.rs

@@ -81,7 +81,6 @@ use uniffi_meta::{MethodMetadata, ObjectMetadata};
 
 /// The main public interface for this module, representing the complete details of an interface exposed
 /// by a rust component and the details of consuming it via an extern-C FFI layer.
-///
 #[derive(Debug, Default)]
 pub struct ComponentInterface {
     /// Every ComponentInterface gets tagged with the version of uniffi used to create it.
@@ -356,6 +355,7 @@ impl ComponentInterface {
     pub fn ffi_rustbuffer_alloc(&self) -> FFIFunction {
         FFIFunction {
             name: format!("ffi_{}_rustbuffer_alloc", self.ffi_namespace()),
+            is_async: false,
             arguments: vec![FFIArgument {
                 name: "size".to_string(),
                 type_: FFIType::Int32,
@@ -370,6 +370,7 @@ impl ComponentInterface {
     pub fn ffi_rustbuffer_from_bytes(&self) -> FFIFunction {
         FFIFunction {
             name: format!("ffi_{}_rustbuffer_from_bytes", self.ffi_namespace()),
+            is_async: false,
             arguments: vec![FFIArgument {
                 name: "bytes".to_string(),
                 type_: FFIType::ForeignBytes,
@@ -384,6 +385,7 @@ impl ComponentInterface {
     pub fn ffi_rustbuffer_free(&self) -> FFIFunction {
         FFIFunction {
             name: format!("ffi_{}_rustbuffer_free", self.ffi_namespace()),
+            is_async: false,
             arguments: vec![FFIArgument {
                 name: "buf".to_string(),
                 type_: FFIType::RustBuffer,
@@ -398,6 +400,7 @@ impl ComponentInterface {
     pub fn ffi_rustbuffer_reserve(&self) -> FFIFunction {
         FFIFunction {
             name: format!("ffi_{}_rustbuffer_reserve", self.ffi_namespace()),
+            is_async: false,
             arguments: vec![
                 FFIArgument {
                     name: "buf".to_string(),