rid-macro: adding export return types (#13)

This adds support for more return types for function exports via `#[rid::export]`.
It contains some WIP for HashMap support as well. While working on that I realized that in order to send the `keys()` as a `Vec` it needs to be supported first.

I added lots of tests which verify that the following export return types are now supported:

```rs
Vec<&struct>
Vec<&primitive>
Vec<&String>
Vec<&CString>
Vec<&str>
```

In the case of vecs with a _string-like_ type the string value is not resolved until the item in the Vec is accessed in order to push out copying the data to convert to a  `*const char` until the last possible moment.

```rs
// owned
u8, i8, u16, i16 .. u64, i64
bool

// refererences
&u8, &i8, &u16, &i16 .. &u64, &i64
&bool
```

```rs
String, CString
&String, &CString, &str
```

They are sent as `*const char` to Dart.

Enums are converted to `i8` when sent to Dart and serialized back into an enum on the Dart end.

* rid-macro: hash map prepared

- composite supports two inner types
- hash map match branches added with todos
- compiles and all tests pass

* rid-macro: hash map rendering without access methods

* rid-macro: organizing vec dart render in separate dir

* rid-macro: renderable access trait and rendering hash map rust access

* deps: upgrade cbindgen to v0.20.0

* rid-macro: ref respected for return type

* rid-macro: fixed bool return type for exports

* rid-macro: fixed string returns from export

* rid-macro: using access type to distinguish return type render

* test: adding todo app integration test

* rid-macro: fix export Dart return type for enum

* test: adding export tests for current status

* rid-macro: export returning primitive refs

* rid-macro: export for string refs including as_str()

* rid-macro: fix numerous vec export issues

- key to determine if vec access is needed fixed
- vec type names fixed
- now multiple vecs can be exported within the same app which was broken
  before

* rid-macro: rust_type::dart_wrapper_rust_ident now returns string

* rid-macro: vec to return type rendering

- handling enums + struct separately
- handling owned vs. referenced primitives

* rid-macro: export supporting Vec<&enum> return

* rid-macro: Vec<&String> via const char pointer

* rid-macro: adding access_string_ref to utils module

* rid-macro: removing snapshot assertions, covered by integration tests

* rid-macro: Vec<&String> exported via vec of pointers

- strings are resolved individually via access
- this is more efficient as strings are only cloned + provided to dart
  when the vec items is accessed
- to distinguish when to resolve strings immediately and render proper
  return type introduced a RustTypeContext

* rid-macro: semi working Vec<&CString> solution

- realized that CString isn't ffi safe, nor is str

* rid-macro: simplifying access of `Vec<&String|&CString>`

- now we immediately resolve to *const char

* rid-macro: improved way to expose CString struct

* rid-macro: handling Vec<&str> exports

.gitignore

@@ -1,3 +1,6 @@
 /target
 /.idea
 /**/.idea
+tests/dart/**/src/wip.rs
+tests/dart/export/test/wip.dart
+.vimrc

Cargo.toml

@@ -16,7 +16,9 @@ exclude = [
   "examples/dart/clock",
   "examples/dart/todo",
   "examples/dart/wip",
-  "tests/dart/field_access"
+  "tests/dart/field_access",
+  "tests/dart/apps",
+  "tests/dart/export"
 ]
 
 [dependencies]

Makefile

@@ -1,4 +1,6 @@
 ROOT:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
 test:
-	cargo test --all
-	cd $(ROOT)/tests/dart/field_access && $(MAKE) test-all
+	cargo test --all &&                                       \
+	cd $(ROOT)/tests/dart/field_access && $(MAKE) test-all && \
+	cd $(ROOT)/tests/dart/export && $(MAKE) test-all &&       \
+	cd $(ROOT)/tests/dart/apps && $(MAKE) test-all

rid-build/Cargo.toml

@@ -10,7 +10,7 @@ doctest = false
 [dependencies]
 rid_common = { path = "../rid-common" }
 rid_ffi = { path = "../rid-ffi" }
-cbindgen = "0.18.0"
+cbindgen = "0.20.0"
 getrandom = { version = "0.2", features = ["js"] }
 tempfile = "3.2.0"
 

rid-build/src/parsed_bindings.rs

@@ -144,6 +144,7 @@ impl ParsedBindings {
 
         let updated_binding =
             replace_struct_aliases(binding, &structs, &struct_aliases);
+        // let updated_binding = fix_cbindgen_issues(&updated_binding);
 
         let dart_code = join_sections(dart_sections);
         let swift_calls: Vec<String> = function_headers

rid-common/src/constants.rs

@@ -23,6 +23,8 @@ pub const STRING_TO_NATIVE_INT8: &str = "toNativeInt8";
 /// Method invoked to free a CString by resolving and dropping it.
 pub const CSTRING_FREE: &str = "rid_cstring_free";
 
+pub const STRING_REF_ACCESS: &str = "rid_access_string_ref";
+
 /// Name of the module containing all of global rid util methods like string free.
 pub const UTILS_MODULE: &str = "__rid_utils_module";
 

rid-macro-impl/src/common/state.rs

@@ -13,7 +13,7 @@ pub struct ExpandState {
 }
 
 pub enum ImplementationType {
-    VecAccess,
+    CollectionAccess,
     DartEnum,
     UtilsModule,
     Free,
@@ -22,8 +22,8 @@ pub enum ImplementationType {
 impl fmt::Display for ImplementationType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ImplementationType::VecAccess => {
-                write!(f, "VecAccess")
+            ImplementationType::CollectionAccess => {
+                write!(f, "CollectionAccess")
             }
             ImplementationType::DartEnum => {
                 write!(f, "DartEnum")
@@ -68,6 +68,7 @@ impl ExpandState {
         }
     }
 
+    #[cfg(not(test))]
     pub fn unique_ident(&mut self, ident: Ident) -> Ident {
         let idents = self.emitted_idents.as_mut().unwrap();
         let count: u8 = idents.get(&ident).unwrap_or(&0_u8) + 1;
@@ -76,6 +77,13 @@ impl ExpandState {
         id
     }
 
+    // Test results need to be the same, no matter if we run just one or all in whichever order
+    #[cfg(test)]
+    pub fn unique_ident(&mut self, ident: Ident) -> Ident {
+        let id = format_ident!("{}_1", ident);
+        id
+    }
+
     pub fn need_implemtation<K: fmt::Display, V>(
         &mut self,
         impl_type: &ImplementationType,

rid-macro-impl/src/common/tokens.rs

@@ -25,6 +25,29 @@ pub fn resolve_vec_ptr(ty: &syn::Ident) -> TokenStream {
     }
 }
 
+pub fn resolve_hash_set_ptr(ty: &syn::Ident) -> TokenStream {
+    quote_spanned! { ty.span() =>
+        unsafe {
+            assert!(!ptr.is_null());
+            let ptr: *mut ::std::collections::HashSet<#ty> = &mut *ptr;
+            ptr.as_mut().expect("resolve_hash_set_ptr.as_mut failed")
+        }
+    }
+}
+
+pub fn resolve_hash_map_ptr(
+    key_ty: &syn::Ident,
+    val_ty: &syn::Ident,
+) -> TokenStream {
+    quote_spanned! { key_ty.span() =>
+        unsafe {
+            assert!(!ptr.is_null());
+            let ptr: *mut ::std::collections::HashMap<#key_ty, #val_ty> = &mut *ptr;
+            ptr.as_mut().expect("resolve_hash_map_ptr.as_mut failed")
+        }
+    }
+}
+
 pub fn resolve_string_ptr(arg: &syn::Ident, reassign: bool) -> TokenStream {
     if reassign {
         quote_spanned! { arg.span() =>

rid-macro-impl/src/common/utils_module_tokens.rs

@@ -17,9 +17,13 @@ pub fn utils_module_tokens() -> TokenStream {
     if get_state()
         .needs_implementation(&ImplementationType::UtilsModule, UTILS_MODULE)
     {
+        let cstring_struct_declaration = cstring_struct_declaration();
+        let str_struct_declaration = str_struct_declaration();
         let cstring_free = cstring_free();
         quote! {
             mod __rid_utils_module {
+                #str_struct_declaration
+                #cstring_struct_declaration
                 #cstring_free
             }
         }
@@ -28,6 +32,9 @@ pub fn utils_module_tokens() -> TokenStream {
     }
 }
 
+// -----------------
+// CString
+// -----------------
 fn cstring_free() -> TokenStream {
     let cstring_free_ident = format_ident!("{}", CSTRING_FREE);
     quote_spanned! {
@@ -40,3 +47,23 @@ fn cstring_free() -> TokenStream {
         }
     }
 }
+
+// cbindgen doesn't know what CString is, also technically it is not FFI safe.
+// We just use it to point to items in a collection, Never actually sending a pointer directly and
+// resolving it later.
+fn cstring_struct_declaration() -> TokenStream {
+    quote! {
+        #[no_mangle]
+        pub struct CString {}
+    }
+}
+
+// -----------------
+// Str
+// -----------------
+fn str_struct_declaration() -> TokenStream {
+    quote! {
+        #[no_mangle]
+        pub struct str {}
+    }
+}

rid-macro-impl/src/export/attach.rs

@@ -18,6 +18,7 @@ use crate::{
 use crate::{attrs::parse_rid_attrs, common::abort};
 use quote::{format_ident, quote};
 
+use crate::render_common::RenderableAccess;
 use proc_macro2::TokenStream;
 use render_dart::render_instance_method_extension;
 use syn::Ident;
@@ -81,7 +82,7 @@ pub fn rid_export_impl(
             let mut ptr_type_aliases_map =
                 HashMap::<String, TokenStream>::new();
             let mut frees = HashMap::<String, PointerTypeAlias>::new();
-            let mut vec_accesses = HashMap::<Ident, VecAccess>::new();
+            let mut vec_accesses = HashMap::<String, VecAccess>::new();
             let rust_fn_tokens = &parsed
                 .methods
                 .iter()
@@ -119,9 +120,7 @@ pub fn rid_export_impl(
                             );
                         }
                     }
-                    vec_access.map(|x| {
-                        vec_accesses.insert(x.vec_type.rust_ident().clone(), x)
-                    });
+                    vec_access.map(|x| vec_accesses.insert(x.key(), x));
 
                     tokens
                 })
@@ -135,7 +134,7 @@ pub fn rid_export_impl(
 
             let vec_access_tokens = if config.render_vec_access {
                 let needed_vec_accesses = get_state().need_implemtation(
-                    &ImplementationType::VecAccess,
+                    &ImplementationType::CollectionAccess,
                     vec_accesses,
                 );
                 render_vec_accesses(

rid-macro-impl/src/export/export_test.rs

@@ -9,10 +9,18 @@ use crate::export::ExportConfig;
 // More detailed tests with arg/return combinations are tested inside ../render_rust/render_function_export_test.rs
 // -----------------
 
-fn render_export(input: TokenStream) -> TokenStream {
+fn render(input: TokenStream, config: ExportConfig) -> TokenStream {
     let item = syn::parse2::<syn::Item>(input).unwrap();
     let args = syn::AttributeArgs::new();
-    rid_export_impl(item, args, ExportConfig::for_tests())
+    rid_export_impl(item, args, config)
+}
+
+fn render_export(input: TokenStream) -> TokenStream {
+    render(input, ExportConfig::for_tests())
+}
+
+fn render_export_full(input: TokenStream) -> TokenStream {
+    render(input, ExportConfig::default())
 }
 
 // -----------------
@@ -23,6 +31,9 @@ mod struct_impl_methods {
 
     use super::*;
 
+    // -----------------
+    // Returning Self
+    // -----------------
     #[test]
     fn no_args_returning_self() {
         let _attrs = TokenStream::new();
@@ -50,4 +61,59 @@ mod struct_impl_methods {
         let tokens = render_export(input);
         assert_eq!(tokens.to_string().trim(), expected.to_string().trim());
     }
+
+    // -----------------
+    // Returning Vec
+    // -----------------
+    #[test]
+    fn no_args_returning_vec_u8_ref() {
+        let _attrs = TokenStream::new();
+        let input: TokenStream = quote! {
+            #[rid::export]
+            impl MyStruct {
+                #[rid::export]
+                fn get_u8s() -> Vec<&u8> {}
+            }
+        };
+
+        let expected = quote! {
+            #[allow(non_snake_case)]
+            mod __rid_MyStruct_impl_1 {
+                use super::*;
+                fn rid_export_MyStruct_get_u8s() -> rid::RidVec<u8> {
+                    let ret = MyStruct::get_u8s();
+                    let ret: Vec<u8> = ret.into_iter().map(|x| *x).collect();
+                    let ret_ptr = rid::RidVec::from(ret);
+                    ret_ptr
+                }
+            }
+        };
+
+        let tokens = render_export(input);
+        dump_tokens(&tokens);
+        assert_eq!(tokens.to_string().trim(), expected.to_string().trim());
+    }
+}
+
+// DEBUG: export, use this to debug export issues
+mod _debug_export_issues {
+    use crate::common::dump_tokens;
+
+    use super::*;
+
+    // #[test]
+    fn debug_export_issue() {
+        let input: TokenStream = quote! {
+            impl Store {
+                #[rid::export]
+                #[rid::enums(Filter)]
+                pub fn filters_ref(&self) -> Vec<&Filter> {
+                    self.filters.iter().collect()
+                }
+            }
+        };
+
+        let tokens = render_export_full(input);
+        dump_tokens(&tokens);
+    }
 }

rid-macro-impl/src/model/field_access/render_dart_field_access.rs

@@ -5,7 +5,7 @@ use crate::{
     attrs::TypeInfoMap,
     common::abort,
     parse::{dart_type::DartType, ParsedStruct, ParsedStructField},
-    render_common::VecAccessRender,
+    render_common::AccessRender,
     render_dart::RenderDartTypeOpts,
 };
 use rid_common::{DART_FFI, FFI_GEN_BIND, RID_FFI};
@@ -14,7 +14,7 @@ pub struct RenderDartFieldAccessConfig {
     pub comment: String,
     pub render: bool,
     pub tokens: bool,
-    pub vec_accesses: VecAccessRender,
+    pub accesses: AccessRender,
 }
 
 impl Default for RenderDartFieldAccessConfig {
@@ -23,7 +23,7 @@ impl Default for RenderDartFieldAccessConfig {
             comment: "/// ".to_string(),
             render: true,
             tokens: true,
-            vec_accesses: VecAccessRender::Default,
+            accesses: AccessRender::Default,
         }
     }
 }
@@ -34,18 +34,18 @@ impl RenderDartFieldAccessConfig {
             comment: "".to_string(),
             render: false,
             tokens: false,
-            vec_accesses: VecAccessRender::Omit,
+            accesses: AccessRender::Omit,
         }
     }
 }
 
 impl RenderDartFieldAccessConfig {
-    pub fn for_dart_tests(vec_accesses: VecAccessRender) -> Self {
+    pub fn for_dart_tests(accesses: AccessRender) -> Self {
         Self {
             comment: "".to_string(),
             render: true,
             tokens: false,
-            vec_accesses,
+            accesses,
         }
     }
 }
@@ -198,11 +198,22 @@ impl DartType {
                 rid_ffi = RID_FFI,
                 ffi_method = ffi_method_ident
             ),
+            // -----------------
+            // Collection Types
+            // -----------------
             DartType::Vec(_, _) => format!(
                 "{{ return {rid_ffi}.{ffi_method}(this); }}",
                 rid_ffi = RID_FFI,
                 ffi_method = ffi_method_ident
             ),
+            DartType::HashMap(_, _, _) => format!(
+                "{{ return {rid_ffi}.{ffi_method}(this); }}",
+                rid_ffi = RID_FFI,
+                ffi_method = ffi_method_ident
+            ),
+            // -----------------
+            // Invalid
+            // -----------------
             DartType::Unit => {
                 abort!(ffi_method_ident, "Dart get to void field not supported")
             }