Refactor macros information encoding and decoding

frb_codegen/src/library/codegen/parser/hir/hierarchical/mod.rs

@@ -1,34 +1,19 @@
 use crate::codegen::ir::hir::hierarchical::pack::HirPack;
 use crate::codegen::ir::hir::raw::pack::HirRawPack;
-use crate::codegen::parser::hir::hierarchical::crates::parse_crate;
 use crate::codegen::parser::hir::internal_config::ParserHirInternalConfig;
 
 pub(crate) mod crates;
 pub(crate) mod function;
 pub(crate) mod item_type;
 pub(crate) mod mirror_ident;
 pub(crate) mod module;
-mod pub_use;
+pub(crate) mod pack;
 pub(crate) mod struct_or_enum;
-mod third_party_override_transformer;
 pub(crate) mod visibility;
 
 pub(crate) fn parse(
     config: &ParserHirInternalConfig,
     hir_raw: &HirRawPack,
 ) -> anyhow::Result<HirPack> {
-    let pack = parse_raw(config, hir_raw)?;
-    let pack = third_party_override_transformer::transform(pack)?;
-    Ok(pack)
-}
-
-fn parse_raw(config: &ParserHirInternalConfig, hir_raw: &HirRawPack) -> anyhow::Result<HirPack> {
-    let crates = hir_raw
-        .crates
-        .iter()
-        .map(|c| parse_crate(config, &c.syn_file, &c.name))
-        .collect::<anyhow::Result<Vec<_>>>()?
-        .into_iter()
-        .collect();
-    Ok(HirPack { crates })
+    pack::parse_pack(config, hir_raw)
 }

frb_codegen/src/library/codegen/parser/hir/hierarchical/module/mod.rs

@@ -0,0 +1,40 @@
+mod pub_use_transformer;
+mod syn_item;
+
+use crate::codegen::ir::hir::hierarchical::module::{HirModule, HirModuleContent, HirModuleMeta};
+use crate::codegen::parser::hir::hierarchical::function::parse_generalized_functions;
+use crate::codegen::parser::hir::internal_config::ParserHirInternalConfig;
+
+pub(crate) fn parse_module(
+    items: &[syn::Item],
+    meta: HirModuleMeta,
+    config: &ParserHirInternalConfig,
+) -> anyhow::Result<HirModule> {
+    let module = parse_raw(items, meta, config)?;
+    let module = pub_use_transformer::transform(module, items)?;
+    Ok(module)
+}
+
+fn parse_raw(
+    items: &[syn::Item],
+    meta: HirModuleMeta,
+    config: &ParserHirInternalConfig,
+) -> anyhow::Result<HirModule> {
+    let mut scope = HirModuleContent {
+        functions: parse_generalized_functions(items, &meta.namespace)?,
+        ..HirModuleContent::default()
+    };
+
+    for item in items.iter() {
+        syn_item::parse_syn_item(item, &mut scope, config, &meta.namespace, &meta.parent_vis)?;
+    }
+
+    Ok(HirModule {
+        meta,
+        content: scope,
+        raw: (items.iter())
+            .filter(|item| !matches!(item, syn::Item::Mod(_)))
+            .map(|item| quote::quote!(#item).to_string())
+            .collect(),
+    })
+}

frb_codegen/src/library/codegen/parser/hir/hierarchical/pub_use.rs → frb_codegen/src/library/codegen/parser/hir/hierarchical/module/pub_use_transformer.rs

@@ -2,10 +2,7 @@ use crate::codegen::ir::hir::hierarchical::module::HirModule;
 use crate::utils::namespace::Namespace;
 use itertools::Itertools;
 
-pub(crate) fn transform_module_by_pub_use(
-    mut module: HirModule,
-    items: &[syn::Item],
-) -> anyhow::Result<HirModule> {
+pub(crate) fn transform(mut module: HirModule, items: &[syn::Item]) -> anyhow::Result<HirModule> {
     let pub_use_names = parse_pub_use_from_items(items);
     for pub_use_name in pub_use_names {
         transform_module_by_pub_use_single(&mut module, &pub_use_name)?;

frb_codegen/src/library/codegen/parser/hir/hierarchical/module.rs → frb_codegen/src/library/codegen/parser/hir/hierarchical/module/syn_item.rs

@@ -1,51 +1,16 @@
 use crate::codegen::ir::hir::hierarchical::module::{
     HirModule, HirModuleContent, HirModuleMeta, HirVisibility,
 };
-use crate::codegen::parser::hir::hierarchical::function::parse_generalized_functions;
 use crate::codegen::parser::hir::hierarchical::item_type::parse_syn_item_type;
-use crate::codegen::parser::hir::hierarchical::pub_use::transform_module_by_pub_use;
+use crate::codegen::parser::hir::hierarchical::module::parse_module;
 use crate::codegen::parser::hir::hierarchical::struct_or_enum::{
     parse_syn_item_enum, parse_syn_item_struct,
 };
 use crate::codegen::parser::hir::internal_config::ParserHirInternalConfig;
 use crate::utils::namespace::Namespace;
 use syn::ItemMod;
 
-pub(crate) fn parse_module(
-    items: &[syn::Item],
-    meta: HirModuleMeta,
-    config: &ParserHirInternalConfig,
-) -> anyhow::Result<HirModule> {
-    let module = parse_module_raw(items, meta, config)?;
-    let module = transform_module_by_pub_use(module, items)?;
-    Ok(module)
-}
-
-fn parse_module_raw(
-    items: &[syn::Item],
-    meta: HirModuleMeta,
-    config: &ParserHirInternalConfig,
-) -> anyhow::Result<HirModule> {
-    let mut scope = HirModuleContent {
-        functions: parse_generalized_functions(items, &meta.namespace)?,
-        ..HirModuleContent::default()
-    };
-
-    for item in items.iter() {
-        parse_syn_item(item, &mut scope, config, &meta.namespace, &meta.parent_vis)?;
-    }
-
-    Ok(HirModule {
-        meta,
-        content: scope,
-        raw: (items.iter())
-            .filter(|item| !matches!(item, syn::Item::Mod(_)))
-            .map(|item| quote::quote!(#item).to_string())
-            .collect(),
-    })
-}
-
-fn parse_syn_item(
+pub(super) fn parse_syn_item(
     item: &syn::Item,
     scope: &mut HirModuleContent,
     config: &ParserHirInternalConfig,

frb_codegen/src/library/codegen/parser/hir/hierarchical/pack/mod.rs

@@ -0,0 +1,26 @@
+use crate::codegen::ir::hir::hierarchical::pack::HirPack;
+use crate::codegen::ir::hir::raw::pack::HirRawPack;
+use crate::codegen::parser::hir::hierarchical::crates::parse_crate;
+use crate::codegen::parser::hir::internal_config::ParserHirInternalConfig;
+
+mod third_party_override_transformer;
+
+pub(crate) fn parse_pack(
+    config: &ParserHirInternalConfig,
+    hir_raw: &HirRawPack,
+) -> anyhow::Result<HirPack> {
+    let pack = parse_raw(config, hir_raw)?;
+    let pack = third_party_override_transformer::transform(pack)?;
+    Ok(pack)
+}
+
+fn parse_raw(config: &ParserHirInternalConfig, hir_raw: &HirRawPack) -> anyhow::Result<HirPack> {
+    let crates = hir_raw
+        .crates
+        .iter()
+        .map(|c| parse_crate(config, &c.syn_file, &c.name))
+        .collect::<anyhow::Result<Vec<_>>>()?
+        .into_iter()
+        .collect();
+    Ok(HirPack { crates })
+}

frb_codegen/src/library/codegen/parser/mir/function_parser/mod.rs

@@ -11,9 +11,7 @@ use crate::codegen::ir::mir::ty::MirType;
 use crate::codegen::parser::mir::attribute_parser::FrbAttributes;
 use crate::codegen::parser::mir::function_parser::structs::ParseFunctionOutput;
 use crate::codegen::parser::mir::type_parser::misc::parse_comments;
-use crate::codegen::parser::mir::type_parser::{
-    external_impl, TypeParser, TypeParserParsingContext,
-};
+use crate::codegen::parser::mir::type_parser::{TypeParser, TypeParserParsingContext};
 use crate::library::codegen::ir::mir::ty::MirTypeTrait;
 use crate::utils::namespace::{Namespace, NamespacedName};
 use anyhow::{bail, Context};
@@ -203,9 +201,10 @@ impl<'a, 'b> FunctionParser<'a, 'b> {
             return Ok(None);
         };
 
-        let owner_ty_name = external_impl::parse_name_or_original(
-            &(self_ty_path.path.segments.first().unwrap().ident).to_string(),
-        )?;
+        // let owner_ty_name = external_impl::parse_name_or_original(
+        //     &(self_ty_path.path.segments.first().unwrap().ident).to_string(),
+        // )?;
+        let owner_ty_name = (self_ty_path.path.segments.first().unwrap().ident).to_string();
         let syn_ty: Type = parse_str(&owner_ty_name)?;
         Ok(Some(self.type_parser.parse_type(&syn_ty, context)?))
     }

frb_codegen/src/library/codegen/parser/mir/type_parser/enum_or_struct.rs

@@ -3,7 +3,6 @@ use crate::codegen::ir::hir::hierarchical::struct_or_enum::HirStructOrEnum;
 use crate::codegen::ir::hir::hierarchical::syn_item_struct_or_enum::SynItemStructOrEnum;
 use crate::codegen::ir::mir::ty::MirType;
 use crate::codegen::parser::mir::attribute_parser::FrbAttributes;
-use crate::codegen::parser::mir::type_parser::external_impl;
 use crate::codegen::parser::mir::type_parser::misc::parse_type_should_ignore_simple;
 use crate::codegen::parser::mir::type_parser::unencodable::SplayedSegment;
 use crate::library::codegen::ir::mir::ty::MirTypeTrait;
@@ -34,14 +33,14 @@ where
         override_opaque: Option<bool>,
     ) -> anyhow::Result<Option<(MirType, FrbAttributes)>> {
         let (name, _) = last_segment;
-        let name = external_impl::parse_name_or_original(name)?;
+        // let name = external_impl::parse_name_or_original(name)?;
 
-        if let Some(src_object) = self.src_objects().get(&name) {
+        if let Some(src_object) = self.src_objects().get(*name) {
             let src_object = (*src_object).clone();
             let vis = src_object.visibility;
 
             let namespace = &src_object.namespaced_name.namespace;
-            let namespaced_name = NamespacedName::new(namespace.clone(), name.clone());
+            let namespaced_name = NamespacedName::new(namespace.clone(), name.to_string());
 
             let attrs = FrbAttributes::parse(src_object.src.attrs())?;
             let attrs_opaque = override_opaque.or(attrs.opaque());

frb_codegen/src/library/codegen/parser/mir/type_parser/external_impl.rs

@@ -1,50 +1,50 @@
-use anyhow::Result;
-use syn::{parse_str, visit_mut, visit_mut::VisitMut, Path, Type};
-
-pub(crate) fn parse_type(mut ty: Type) -> Result<Type> {
-    struct Visitor;
-    impl VisitMut for Visitor {
-        fn visit_path_mut(&mut self, node: &mut Path) {
-            if node.segments.len() == 1 {
-                let ident = &node.segments[0].ident;
-                if let Some(reconstructed_name) = parse_name(&ident.to_string()).unwrap() {
-                    // println!("hi {node:?} {reconstructed_name}");
-                    *node = parse_str(&reconstructed_name).unwrap();
-                }
-            }
-
-            visit_mut::visit_path_mut(self, node);
-        }
-    }
-    Visitor.visit_type_mut(&mut ty);
-    Ok(ty)
-}
-
-pub(crate) fn parse_name_or_original(raw_name: &str) -> Result<String> {
-    Ok(parse_name(raw_name)?.unwrap_or_else(|| raw_name.to_string()))
-}
-
-fn parse_name(raw_name: &str) -> Result<Option<String>> {
-    const DUMMY_STRUCT_PREFIX: &str = "__external_impl__";
-    Ok(
-        if let Some(stripped_name) = raw_name.strip_prefix(DUMMY_STRUCT_PREFIX) {
-            Some(String::from_utf8(hex::decode(stripped_name)?)?)
-        } else {
-            None
-        },
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_external_impl_dummy_struct_name() {
-        assert_eq!(parse_name("One<Two,Three>").unwrap(), None);
-        assert_eq!(
-            parse_name("__external_impl__4f6e65203c2054776f2c205468726565203e").unwrap(),
-            Some("One < Two, Three >".to_owned()),
-        );
-    }
-}
+// use anyhow::Result;
+// use syn::{parse_str, visit_mut, visit_mut::VisitMut, Path, Type};
+//
+// pub(crate) fn parse_type(mut ty: Type) -> Result<Type> {
+//     struct Visitor;
+//     impl VisitMut for Visitor {
+//         fn visit_path_mut(&mut self, node: &mut Path) {
+//             if node.segments.len() == 1 {
+//                 let ident = &node.segments[0].ident;
+//                 if let Some(reconstructed_name) = parse_name(&ident.to_string()).unwrap() {
+//                     // println!("hi {node:?} {reconstructed_name}");
+//                     *node = parse_str(&reconstructed_name).unwrap();
+//                 }
+//             }
+//
+//             visit_mut::visit_path_mut(self, node);
+//         }
+//     }
+//     Visitor.visit_type_mut(&mut ty);
+//     Ok(ty)
+// }
+//
+// pub(crate) fn parse_name_or_original(raw_name: &str) -> Result<String> {
+//     Ok(parse_name(raw_name)?.unwrap_or_else(|| raw_name.to_string()))
+// }
+//
+// fn parse_name(raw_name: &str) -> Result<Option<String>> {
+//     const DUMMY_STRUCT_PREFIX: &str = "__external_impl__";
+//     Ok(
+//         if let Some(stripped_name) = raw_name.strip_prefix(DUMMY_STRUCT_PREFIX) {
+//             Some(String::from_utf8(hex::decode(stripped_name)?)?)
+//         } else {
+//             None
+//         },
+//     )
+// }
+//
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+//
+//     #[test]
+//     fn test_parse_external_impl_dummy_struct_name() {
+//         assert_eq!(parse_name("One<Two,Three>").unwrap(), None);
+//         assert_eq!(
+//             parse_name("__external_impl__4f6e65203c2054776f2c205468726565203e").unwrap(),
+//             Some("One < Two, Three >".to_owned()),
+//         );
+//     }
+// }

frb_codegen/src/library/codegen/parser/mir/type_parser/rust_auto_opaque_implicit.rs

@@ -6,7 +6,6 @@ use crate::codegen::ir::mir::ty::rust_opaque::{
     MirRustOpaqueInner, MirTypeRustOpaque, RustOpaqueCodecMode,
 };
 use crate::codegen::ir::mir::ty::{MirType, MirTypeTrait};
-use crate::codegen::parser::mir::type_parser::external_impl;
 use crate::codegen::parser::mir::type_parser::path_data::extract_path_data;
 use crate::codegen::parser::mir::type_parser::rust_opaque::{
     GeneralizedRustOpaqueParserInfo, RustOpaqueParserTypeInfo,
@@ -42,7 +41,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> {
         namespace: Option<Namespace>,
         codec: Option<RustOpaqueCodecMode>,
     ) -> Result<(MirRustAutoOpaqueRaw, MirTypeRustOpaque)> {
-        let inner = external_impl::parse_type(inner)?;
+        // let inner = external_impl::parse_type(inner)?;
 
         let inner_str = inner.to_token_stream().to_string();
         let info = self.get_or_insert_rust_auto_opaque_info(&inner_str, namespace, codec);