chore: separate access code (#22)

 Vec accesses and HashMap accesses and the governing `RenderableAccess` trait now live in a
 dedicated module, moved out from field access.
 Field specific access configs have been changed to just access configs.
 
 Exports now also render vec accesses via the `RenderableAccess` functions instead of using vec
 access render directly.

* rid-macro: cleaning vec access in hash map

- stuck around from previous implementation
- no longer needed as hash map uses `rid::export` for keys

* rid-macro: moving access code to separate module and use for export

- accesses lived as part of field access, but they are used for
  MethodReturn (function exports) as well
- function exports used `vec` access render directly, that's been
  changed to use the access trait render methods like is done for fields

rid-macro-impl/src/render_common/access.rs → rid-macro-impl/src/accesses/access.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use proc_macro2::{Span, TokenStream};
 
-use crate::attrs::TypeInfoMap;
+use crate::{attrs::TypeInfoMap, render_common::PointerTypeAlias};
 
-use super::{HashMapAccess, PointerTypeAlias, VecAccess};
+use super::{HashMapAccess, VecAccess};
 
 /// Distinguishes between accesses that are references to fields on structs or enums vs.
 /// instances created during a method call and returned to Dart without keeping a reference

rid-macro-impl/src/accesses/mod.rs

@@ -0,0 +1,9 @@
+mod access;
+mod hash_map;
+mod render_collection_accesses;
+mod vec;
+
+pub use access::*;
+pub use hash_map::*;
+pub use render_collection_accesses::*;
+pub use vec::*;

rid-macro-impl/src/model/field_access/render_collection_accesses.rs → rid-macro-impl/src/accesses/render_collection_accesses.rs

@@ -6,17 +6,95 @@ use quote::{format_ident, quote, quote_spanned};
 use crate::{
     attrs::TypeInfoMap,
     common::state::{get_state, ImplementationType},
-    render_common::{
-        AccessKind, AccessRender, HashMapAccess, RenderableAccess,
-        RenderedAccessRust, VecAccess,
-    },
+    render_rust::ffi_prelude,
 };
 
 use super::{
-    render_dart_field_access::RenderDartFieldAccessConfig,
-    render_rust_field_access::RenderRustFieldAccessConfig,
+    AccessRender, HashMapAccess, RenderableAccess, RenderedAccessRust,
+    VecAccess,
 };
 
+// -----------------
+// RenderRustAccessConfig
+// -----------------
+pub struct RenderRustAccessConfig {
+    pub accesses: AccessRender,
+    pub ffi_prelude_tokens: TokenStream,
+    pub render: bool,
+}
+
+impl Default for RenderRustAccessConfig {
+    fn default() -> Self {
+        Self {
+            ffi_prelude_tokens: ffi_prelude(),
+            render: true,
+            accesses: AccessRender::Default,
+        }
+    }
+}
+impl RenderRustAccessConfig {
+    pub fn for_rust_tests(accesses: AccessRender) -> Self {
+        Self {
+            ffi_prelude_tokens: TokenStream::new(),
+            render: true,
+            accesses,
+        }
+    }
+}
+
+impl RenderRustAccessConfig {
+    pub fn for_dart_tests(accesses: AccessRender) -> Self {
+        Self {
+            ffi_prelude_tokens: TokenStream::new(),
+            render: false,
+            accesses,
+        }
+    }
+}
+
+// -----------------
+// RenderRustAccessConfig
+// -----------------
+pub struct RenderDartAccessConfig {
+    pub accesses: AccessRender,
+    pub render: bool,
+    pub tokens: bool,
+    pub comment: String,
+}
+
+impl Default for RenderDartAccessConfig {
+    fn default() -> Self {
+        Self {
+            comment: "/// ".to_string(),
+            render: true,
+            tokens: true,
+            accesses: AccessRender::Default,
+        }
+    }
+}
+
+impl RenderDartAccessConfig {
+    pub fn for_rust_tests() -> Self {
+        Self {
+            comment: "".to_string(),
+            render: false,
+            tokens: false,
+            accesses: AccessRender::Omit,
+        }
+    }
+}
+
+impl RenderDartAccessConfig {
+    pub fn for_dart_tests(accesses: AccessRender) -> Self {
+        Self {
+            comment: "".to_string(),
+            render: true,
+            tokens: false,
+            accesses,
+        }
+    }
+}
+
 struct AggregatedRenderedAccesses {
     rust_tokens: Vec<TokenStream>,
     darts: Vec<String>,
@@ -25,8 +103,8 @@ struct AggregatedRenderedAccesses {
 pub fn render_collection_accesses(
     accesses: HashMap<String, Box<dyn RenderableAccess>>,
     type_infos: &TypeInfoMap,
-    rust_config: &RenderRustFieldAccessConfig,
-    dart_config: &RenderDartFieldAccessConfig,
+    rust_config: &RenderRustAccessConfig,
+    dart_config: &RenderDartAccessConfig,
 ) -> (TokenStream, String) {
     if accesses.is_empty() {
         return (TokenStream::new(), String::new());
@@ -85,19 +163,16 @@ pub fn render_collection_accesses(
 fn aggregate_collection_accesses(
     accesses: HashMap<String, Box<dyn RenderableAccess>>,
     type_infos: &TypeInfoMap,
-    rust_config: &RenderRustFieldAccessConfig,
-    dart_config: &RenderDartFieldAccessConfig,
+    rust_config: &RenderRustAccessConfig,
+    dart_config: &RenderDartAccessConfig,
 ) -> AggregatedRenderedAccesses {
-    let mut all_nested_accesses: HashMap<String, Box<dyn RenderableAccess>> =
-        HashMap::new();
-
     if accesses.is_empty() {
         AggregatedRenderedAccesses {
             rust_tokens: vec![],
             darts: vec![],
         }
     } else {
-        let mut aggregated = accesses.values().into_iter().fold(
+        let aggregated = accesses.values().into_iter().fold(
             AggregatedRenderedAccesses {
                 rust_tokens: vec![],
                 darts: vec![],

rid-macro-impl/src/render_common/vec.rs → rid-macro-impl/src/accesses/vec.rs

@@ -1,10 +1,7 @@
 use proc_macro2::TokenStream;
 use syn::Ident;
 
-use crate::{
-    attrs::TypeInfoMap, parse::rust_type::RustType,
-    render_common::RenderableAccess,
-};
+use crate::{attrs::TypeInfoMap, parse::rust_type::RustType};
 use quote::{format_ident, quote};
 
 use super::AccessKind;
@@ -81,34 +78,3 @@ impl VecAccess {
         .to_lowercase()
     }
 }
-
-pub fn render_vec_accesses(
-    vec_accesses: &[VecAccess],
-    type_infos: &TypeInfoMap,
-    comment: &str,
-) -> Vec<TokenStream> {
-    vec_accesses
-        .iter()
-        .map(|x| {
-            let rust_tokens = x.render_rust().tokens;
-
-            let implement_vecs = x.render_dart(type_infos, comment);
-            let dart_string: String = format!(
-                r###"
-            {comment} Vector access methods matching the below Rust methods.
-            {comment}
-            {comment} ```dart
-            {implement_vecs}
-            {comment} ```"###,
-                comment = comment,
-                implement_vecs = implement_vecs
-            );
-            let dart_tokens: TokenStream = dart_string.parse().unwrap();
-
-            quote! {
-                #dart_tokens
-                #rust_tokens
-            }
-        })
-        .collect()
-}

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

@@ -1,16 +1,14 @@
 use std::collections::HashMap;
 
 use crate::{
+    accesses::RenderableAccess,
     attrs::{self, FunctionConfig, ImplBlockConfig},
     common::{
         state::{get_state, ImplementationType},
         utils_module_tokens_if,
     },
     parse::{ParsedFunction, ParsedImplBlock},
-    render_common::{
-        render_vec_accesses, PointerTypeAlias, RenderFunctionExportConfig,
-        VecAccess,
-    },
+    render_common::{PointerTypeAlias, RenderFunctionExportConfig},
     render_dart,
     render_rust::{self, ffi_prelude, render_free, RenderedTypeAliasInfo},
 };
@@ -24,7 +22,6 @@ use super::{
 use crate::{attrs::parse_rid_attrs, common::abort};
 use quote::{format_ident, quote, quote_spanned};
 
-use crate::render_common::RenderableAccess;
 use proc_macro2::TokenStream;
 use render_dart::render_instance_method_extension;
 use syn::Ident;
@@ -41,7 +38,8 @@ pub fn rid_export_impl(
 
             let mut ptr_type_aliases_map =
                 HashMap::<String, TokenStream>::new();
-            let mut vec_accesses = HashMap::<String, VecAccess>::new();
+            let mut accesses =
+                HashMap::<String, Box<dyn RenderableAccess>>::new();
             let rust_fn_tokens = &parsed
                 .methods
                 .iter()
@@ -54,7 +52,7 @@ pub fn rid_export_impl(
                         Some(parsed.ty.rust_ident().clone()),
                         config.include_ffi,
                         &mut ptr_type_aliases_map,
-                        &mut vec_accesses,
+                        &mut accesses,
                     )
                 })
                 .collect::<Vec<TokenStream>>();
@@ -66,11 +64,11 @@ pub fn rid_export_impl(
             ));
 
             let ExtractedTokens {
-                vec_access_tokens,
+                access_tokens,
                 ptr_typedef_tokens,
                 utils_module,
             } = extract_tokens(
-                vec_accesses,
+                accesses,
                 &ptr_type_aliases_map,
                 parsed.type_infos(),
                 &config,
@@ -92,7 +90,7 @@ pub fn rid_export_impl(
                     #(#ptr_typedef_tokens)*
                     #dart_extension_tokens
                     #(#rust_fn_tokens)*
-                    #(#vec_access_tokens)*
+                    #access_tokens
                     #utils_module
                 }
             }
@@ -118,22 +116,23 @@ pub fn rid_export_impl(
 
             let mut ptr_type_aliases_map =
                 HashMap::<String, TokenStream>::new();
-            let mut vec_accesses = HashMap::<String, VecAccess>::new();
+            let mut accesses =
+                HashMap::<String, Box<dyn RenderableAccess>>::new();
 
             let rust_fn_tokens = process_function_export(
                 &parsed_fn,
                 owner_type_infos,
                 config.include_ffi,
                 &mut ptr_type_aliases_map,
-                &mut vec_accesses,
+                &mut accesses,
             );
 
             let ExtractedTokens {
-                vec_access_tokens,
+                access_tokens,
                 ptr_typedef_tokens,
                 utils_module,
             } = extract_tokens(
-                vec_accesses,
+                accesses,
                 &ptr_type_aliases_map,
                 parsed_fn.type_infos(),
                 &config,
@@ -148,7 +147,7 @@ pub fn rid_export_impl(
                     use super::*;
                     #(#ptr_typedef_tokens)*
                     #rust_fn_tokens
-                    #(#vec_access_tokens)*
+                    #access_tokens
                     #utils_module
                 }
             }

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

@@ -4,16 +4,14 @@ use proc_macro2::TokenStream;
 use syn::Ident;
 
 use crate::{
+    accesses::{render_collection_accesses, RenderableAccess},
     attrs::TypeInfoMap,
     common::{
         state::{get_state, ImplementationType},
         utils_module_tokens_if,
     },
     parse::{rust_type::RustType, ParsedFunction},
-    render_common::{
-        render_vec_accesses, PointerTypeAlias, RenderFunctionExportConfig,
-        RenderableAccess, VecAccess,
-    },
+    render_common::{PointerTypeAlias, RenderFunctionExportConfig},
     render_dart::render_instance_method_extension,
     render_rust::{self, ffi_prelude, RenderedTypeAliasInfo},
 };
@@ -25,7 +23,7 @@ pub fn process_function_export(
     impl_ident: Option<Ident>,
     include_ffi: bool,
     ptr_type_aliases_map: &mut HashMap<String, TokenStream>,
-    vec_accesses: &mut HashMap<String, VecAccess>,
+    accesses: &mut HashMap<String, Box<dyn RenderableAccess>>,
 ) -> TokenStream {
     {
         let render_rust::RenderedFunctionExport {
@@ -58,37 +56,37 @@ pub fn process_function_export(
                 panic!("Rid removed free implementation for Rust and Dart since it wasn't complete nor used");
             }
         }
-        vec_access.map(|x| vec_accesses.insert(x.key(), x));
+        vec_access.map(|x| accesses.insert(x.key(), Box::new(x)));
 
         tokens
     }
 }
 
 pub struct ExtractedTokens<'a> {
-    pub vec_access_tokens: Vec<TokenStream>,
+    pub access_tokens: TokenStream,
     pub ptr_typedef_tokens: Vec<&'a TokenStream>,
     pub utils_module: TokenStream,
 }
 
 pub fn extract_tokens<'a>(
-    collection_accesses: HashMap<String, VecAccess>,
+    accesses: HashMap<String, Box<dyn RenderableAccess>>,
     ptr_type_aliases_map: &'a HashMap<String, TokenStream>,
     type_infos: &TypeInfoMap,
     config: &ExportConfig,
 ) -> ExtractedTokens<'a> {
     // -----------------
     // Collection Accesses
     // -----------------
-    // TODO(thlorenz): Generalize to all collections via RenderableAccess
-    // see src/model/field_access/render_collection_accesses.rs
-    let collection_access_tokens = if config.render_collection_access {
-        let needed_accesses = get_state().need_implemtation(
-            &ImplementationType::CollectionAccess,
-            collection_accesses,
-        );
-        render_vec_accesses(&needed_accesses, type_infos, "///")
+    let access_tokens = if config.render_collection_access {
+        render_collection_accesses(
+            accesses,
+            type_infos,
+            &Default::default(),
+            &Default::default(),
+        )
+        .0
     } else {
-        vec![]
+        TokenStream::new()
     };
 
     // -----------------
@@ -103,7 +101,7 @@ pub fn extract_tokens<'a>(
     let utils_module = utils_module_tokens_if(config.render_utils_module);
 
     ExtractedTokens {
-        vec_access_tokens: collection_access_tokens,
+        access_tokens,
         ptr_typedef_tokens,
         utils_module,
     }