Support automatic scanning of third party crates (part 1)

frb_codegen/src/binary/commands_parser.rs

@@ -66,6 +66,7 @@ fn compute_codegen_config_from_naive_command_args(
         full_dep: Some(args.full_dep),
         local: Some(args.local),
         default_external_library_loader_web_prefix: args.default_external_library_loader_web_prefix,
+        dart_type_rename: None, // complex type, not supported on command line yet
         dump: args.dump,
         dump_all: Some(args.dump_all),
     })

frb_codegen/src/library/codegen/config/config.rs

@@ -1,5 +1,6 @@
 use crate::codegen::dumper::internal_config::ConfigDumpContent;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 /// Configuration for code generation
 /// Refer to `GenerateCommandArgs` for documentations
@@ -29,6 +30,7 @@ pub struct Config {
     pub full_dep: Option<bool>,
     pub local: Option<bool>,
     pub default_external_library_loader_web_prefix: Option<String>,
+    pub dart_type_rename: Option<HashMap<String, String>>,
     pub dump: Option<Vec<ConfigDumpContent>>,
     pub dump_all: Option<bool>,
 }

frb_codegen/src/library/codegen/config/internal_config_parser/generator_parser.rs

@@ -16,9 +16,11 @@ use crate::codegen::Config;
 use crate::library::commands::cargo_metadata::execute_cargo_metadata;
 use crate::utils::dart_repository::get_dart_package_name;
 use crate::utils::path_utils::path_to_string;
+use crate::utils::syn_utils::canonicalize_rust_type;
 use anyhow::Context;
 use itertools::Itertools;
 use pathdiff::diff_paths;
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 pub(super) struct Args<'a> {
@@ -61,8 +63,10 @@ pub(super) fn parse(args: Args) -> anyhow::Result<GeneratorInternalConfig> {
             dart_enums_style,
             dart3,
             dart_decl_base_output_path: dart_output_path_pack.dart_decl_base_output_path.clone(),
+            dart_impl_output_path: dart_output_path_pack.dart_impl_output_path.clone(),
             dart_entrypoint_class_name: dart_output_class_name_pack.entrypoint_class_name.clone(),
             dart_preamble: config.dart_preamble.clone().unwrap_or_default(),
+            dart_type_rename: compute_dart_type_rename(config)?,
         },
         wire: GeneratorWireInternalConfig {
             dart: GeneratorWireDartInternalConfig {
@@ -168,3 +172,31 @@ fn compute_default_external_library_relative_directory(
     let diff = diff_paths(rust_crate_dir, dart_root).context("cannot diff path")?;
     Ok(path_to_string(&diff.join("target").join("release/"))?.replace('\\', "/"))
 }
+
+fn compute_dart_type_rename(config: &Config) -> anyhow::Result<HashMap<String, String>> {
+    fn convert_rust_type(raw: &str) -> anyhow::Result<Vec<String>> {
+        Ok(vec![
+            canonicalize_rust_type(raw)?,
+            canonicalize_rust_type(&format!(
+                "flutter_rust_bridge::for_generated::RustAutoOpaqueInner<{}>",
+                raw
+            ))?,
+        ])
+    }
+
+    Ok(config
+        .dart_type_rename
+        .clone()
+        .unwrap_or_default()
+        .iter()
+        .map(|(k, v)| {
+            Ok(convert_rust_type(k)?
+                .into_iter()
+                .map(|parsed_k| (parsed_k, v.to_owned()))
+                .collect_vec())
+        })
+        .collect::<anyhow::Result<Vec<_>>>()?
+        .into_iter()
+        .flatten()
+        .collect())
+}

frb_codegen/src/library/codegen/config/internal_config_parser/mod.rs

@@ -36,6 +36,7 @@ impl InternalConfig {
             rust_path_migrator::migrate_rust_input_config(&config.rust_root, &config.rust_input)?;
         let RustInputInfo {
             rust_crate_dir,
+            third_party_crate_names,
             rust_input_namespace_pack,
         } = rust_path_parser::compute_rust_input_info(&migrated_rust_input, &base_dir)?;
 
@@ -96,15 +97,16 @@ impl InternalConfig {
             },
             parser: ParserInternalConfig {
                 hir: ParserHirInternalConfig {
+                    rust_crate_dir: rust_crate_dir.clone(),
                     rust_input_namespace_pack: rust_input_namespace_pack.clone(),
+                    third_party_crate_names,
                 },
                 mir: ParserMirInternalConfig {
                     rust_input_namespace_pack: rust_input_namespace_pack.clone(),
                     force_codec_mode_pack: compute_force_codec_mode_pack(full_dep),
                     default_stream_sink_codec,
                     default_rust_opaque_codec,
                 },
-                rust_crate_dir: rust_crate_dir.clone(),
             },
             generator,
             polisher: PolisherInternalConfig {

frb_codegen/src/library/codegen/config/internal_config_parser/rust_path_parser.rs

@@ -1,69 +1,52 @@
 use crate::codegen::config::internal_config_parser::dart_path_parser::compute_path_map;
 use crate::codegen::config::internal_config_parser::rust_path_migrator::ConfigRustRootAndRustInput;
 use crate::codegen::generator::misc::target::TargetOrCommonMap;
-use crate::codegen::ir::mir::namespace::Namespace;
 use crate::codegen::parser::mir::internal_config::RustInputNamespacePack;
 use crate::codegen::Config;
+use crate::utils::crate_name::CrateName;
+use crate::utils::namespace::Namespace;
 use crate::utils::path_utils::canonicalize_with_error_message;
 use anyhow::Context;
 use itertools::Itertools;
 use std::path::{Path, PathBuf};
 
 pub(super) struct RustInputInfo {
     pub rust_crate_dir: PathBuf,
+    pub third_party_crate_names: Vec<CrateName>,
     pub rust_input_namespace_pack: RustInputNamespacePack,
 }
 
 pub(super) fn compute_rust_input_info(
     migrated_rust_input: &ConfigRustRootAndRustInput,
     base_dir: &Path,
 ) -> anyhow::Result<RustInputInfo> {
+    let rust_input_namespace_prefixes_raw =
+        compute_rust_input_namespace_prefixes_raw(&migrated_rust_input.rust_input);
+
     Ok(RustInputInfo {
         rust_crate_dir: compute_rust_crate_dir(base_dir, &migrated_rust_input.rust_root)?,
-        rust_input_namespace_pack: compute_rust_input_namespace_pack(
-            &migrated_rust_input.rust_input,
-        )?,
+        third_party_crate_names: compute_third_party_crate_names(
+            &rust_input_namespace_prefixes_raw,
+        ),
+        rust_input_namespace_pack: RustInputNamespacePack {
+            rust_input_namespace_prefixes: tidy_rust_input_namespace_prefixes(
+                &rust_input_namespace_prefixes_raw,
+            ),
+        },
     })
 }
 
-fn compute_rust_input_namespace_pack(
-    raw_rust_input: &str,
-) -> anyhow::Result<RustInputNamespacePack> {
-    Ok(RustInputNamespacePack::new(
-        raw_rust_input
-            .split(',')
-            .map(|s| Namespace::new_raw(s.to_owned()))
-            .collect_vec(),
-    ))
+fn compute_rust_input_namespace_prefixes_raw(raw_rust_input: &str) -> Vec<Namespace> {
+    raw_rust_input
+        .split(',')
+        .map(|s| Namespace::new_raw(s.to_owned()))
+        .collect_vec()
+}
 
-    // const BLACKLIST_FILE_NAMES: [&str; 1] = ["mod.rs"];
-    //
-    // let glob_pattern = base_dir.join(raw_rust_input);
-    //
-    // let mut pack = RustInputNamespacePack {
-    //     rust_input_namespaces: vec![],
-    // };
-    // for path in glob_path(&glob_pattern)?.into_iter() {
-    //     if BLACKLIST_FILE_NAMES.contains(&path.file_name().unwrap().to_str().unwrap()) {
-    //         pack.rust_suppressed_input_namespaces.push(path);
-    //     } else {
-    //         pack.rust_input_namespaces.push(path);
-    //     }
-    // }
-    //
-    // // This will stop the whole generator and tell the users, so we do not care about testing it
-    // // frb-coverage:ignore-start
-    // ensure!(
-    //     !pack.rust_input_namespaces.is_empty(),
-    //     "Find zero rust input paths. (glob_pattern={glob_pattern:?})"
-    // );
-    // // ensure!(
-    // //     !pack.rust_input_namespaces.iter().any(|p| path_to_string(p).unwrap().contains("lib.rs")),
-    // //     "Do not use `lib.rs` as a Rust input. Please put code to be generated in something like `api.rs`.",
-    // // );
-    // // frb-coverage:ignore-end
-    //
-    // Ok(pack)
+fn tidy_rust_input_namespace_prefixes(raw: &[Namespace]) -> Vec<Namespace> {
+    raw.iter()
+        .map(|x| Namespace::new_raw(x.joined_path.replace('-', "_")))
+        .collect_vec()
 }
 
 fn compute_rust_crate_dir(base_dir: &Path, rust_root: &str) -> anyhow::Result<PathBuf> {
@@ -85,3 +68,16 @@ pub(super) fn compute_rust_output_path(
 fn fallback_rust_output_path(rust_crate_dir: &Path) -> PathBuf {
     rust_crate_dir.join("src").join("frb_generated.rs")
 }
+
+fn compute_third_party_crate_names(
+    rust_input_namespace_prefixes_raw: &[Namespace],
+) -> Vec<CrateName> {
+    rust_input_namespace_prefixes_raw
+        .iter()
+        .map(|x| x.path()[0])
+        .filter(|x| *x != CrateName::SELF_CRATE)
+        .dedup()
+        .sorted()
+        .map(|x| CrateName::new(x.to_owned()))
+        .collect_vec()
+}

frb_codegen/src/library/codegen/dumper/internal_config.rs

@@ -16,6 +16,7 @@ pub(crate) struct DumperInternalConfig {
 pub enum ConfigDumpContent {
     Config,
     Source,
+    Hir,
     Mir,
     GeneratorInfo,
     GeneratorSpec,

frb_codegen/src/library/codegen/generator/api_dart/internal_config.rs

@@ -1,11 +1,15 @@
+use crate::codegen::generator::misc::target::TargetOrCommonMap;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::path::PathBuf;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub(crate) struct GeneratorApiDartInternalConfig {
     pub dart_enums_style: bool,
     pub dart3: bool,
     pub dart_decl_base_output_path: PathBuf,
+    pub dart_impl_output_path: TargetOrCommonMap<PathBuf>,
     pub dart_entrypoint_class_name: String,
     pub dart_preamble: String,
+    pub dart_type_rename: HashMap<String, String>,
 }

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/method.rs

@@ -7,9 +7,9 @@ use crate::codegen::ir::mir::func::{
     MirFunc, MirFuncAccessorMode, MirFuncArgMode, MirFuncDefaultConstructorMode, MirFuncOwnerInfo,
     MirFuncOwnerInfoMethod, MirFuncOwnerInfoMethodMode,
 };
-use crate::codegen::ir::mir::namespace::NamespacedName;
 use crate::if_then_some;
 use crate::library::codegen::generator::api_dart::spec_generator::base::*;
+use crate::utils::namespace::NamespacedName;
 use convert_case::{Case, Casing};
 use itertools::Itertools;
 

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/mod.rs

@@ -1,5 +1,5 @@
-use crate::codegen::ir::mir::namespace::Namespace;
 use crate::utils::basic_code::DartBasicHeaderCode;
+use crate::utils::namespace::Namespace;
 use serde::Serialize;
 
 pub(crate) mod field;

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/rust_opaque.rs

@@ -2,11 +2,11 @@ use crate::codegen::generator::api_dart::spec_generator::class::method::generate
 use crate::codegen::generator::api_dart::spec_generator::class::misc::generate_class_extra_body;
 use crate::codegen::generator::api_dart::spec_generator::class::ty::ApiDartGeneratorClassTrait;
 use crate::codegen::generator::api_dart::spec_generator::class::ApiDartGeneratedClass;
-use crate::codegen::ir::mir::namespace::NamespacedName;
 use crate::codegen::ir::mir::ty::rust_opaque::MirTypeRustOpaque;
 use crate::library::codegen::generator::api_dart::spec_generator::base::*;
 use crate::library::codegen::generator::api_dart::spec_generator::info::ApiDartGeneratorInfoTrait;
 use crate::library::codegen::ir::mir::ty::MirTypeTrait;
+use crate::utils::namespace::NamespacedName;
 use lazy_static::lazy_static;
 use regex::Regex;
 

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/function.rs

@@ -7,12 +7,12 @@ use crate::codegen::generator::api_dart::spec_generator::misc::{
 };
 use crate::codegen::ir::mir::field::MirField;
 use crate::codegen::ir::mir::func::{MirFunc, MirFuncArgMode, MirFuncMode};
-use crate::codegen::ir::mir::namespace::Namespace;
 use crate::codegen::ir::mir::ty::delegate::{MirTypeDelegate, MirTypeDelegateStreamSink};
 use crate::codegen::ir::mir::ty::MirType;
 use crate::if_then_some;
 use crate::library::codegen::generator::api_dart::spec_generator::info::ApiDartGeneratorInfoTrait;
 use crate::utils::basic_code::DartBasicHeaderCode;
+use crate::utils::namespace::Namespace;
 use itertools::Itertools;
 use serde::Serialize;
 

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs

@@ -6,6 +6,7 @@ use crate::codegen::ir::mir::ty::delegate::{
 use crate::codegen::ir::mir::ty::general_list::MirTypeGeneralList;
 use crate::codegen::ir::mir::ty::primitive::MirTypePrimitive;
 use crate::codegen::ir::mir::ty::{MirType, MirTypeTrait};
+use crate::utils::syn_utils::canonicalize_rust_type;
 use convert_case::{Case, Casing};
 use enum_dispatch::enum_dispatch;
 use itertools::Itertools;
@@ -217,7 +218,12 @@ impl<'a> ApiDartGeneratorInfoTrait for RustAutoOpaqueImplicitApiDartGenerator<'a
 
 impl<'a> ApiDartGeneratorInfoTrait for RustOpaqueApiDartGenerator<'a> {
     fn dart_api_type(&self) -> String {
-        self.mir.sanitized_type()
+        self.context
+            .config
+            .dart_type_rename
+            .get(&canonicalize_rust_type(&self.mir.inner.0).unwrap())
+            .cloned()
+            .unwrap_or_else(|| self.mir.sanitized_type())
     }
 }
 

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/misc.rs

@@ -5,11 +5,11 @@ use crate::codegen::ir::mir::annotation::MirDartAnnotation;
 use crate::codegen::ir::mir::comment::MirComment;
 use crate::codegen::ir::mir::func::MirFunc;
 use crate::codegen::ir::mir::import::MirDartImport;
-use crate::codegen::ir::mir::namespace::Namespace;
 use crate::codegen::ir::mir::pack::DistinctTypeGatherer;
 use crate::codegen::ir::mir::ty::MirType;
 use crate::library::codegen::generator::api_dart::spec_generator::info::ApiDartGeneratorInfoTrait;
 use crate::library::codegen::ir::mir::ty::MirTypeTrait;
+use crate::utils::namespace::Namespace;
 use crate::utils::path_utils::path_to_string;
 use anyhow::Context;
 use itertools::Itertools;

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/mod.rs

@@ -9,15 +9,16 @@ use crate::codegen::generator::api_dart::spec_generator::function::ApiDartGenera
 use crate::codegen::generator::api_dart::spec_generator::misc::generate_imports_which_types_and_funcs_use;
 use crate::codegen::generator::api_dart::spec_generator::sanity_checker::sanity_check_class_name_duplicates;
 use crate::codegen::ir::mir::func::{MirFunc, MirFuncOwnerInfo};
-use crate::codegen::ir::mir::namespace::Namespace;
 use crate::codegen::ir::mir::pack::{MirPack, MirPackComputedCache};
+use crate::codegen::ir::mir::skip::{MirSkip, MirSkipReason};
 use crate::codegen::ir::mir::ty::MirType;
 use crate::codegen::ConfigDumpContent;
 use crate::library::codegen::generator::api_dart::spec_generator::class::ty::ApiDartGeneratorClassTrait;
 use crate::library::codegen::ir::mir::ty::MirTypeTrait;
 use crate::utils::basic_code::DartBasicHeaderCode;
+use crate::utils::namespace::Namespace;
 use anyhow::Result;
-use itertools::Itertools;
+use itertools::{concat, Itertools};
 use serde::Serialize;
 use std::collections::{HashMap, HashSet};
 use ConfigDumpContent::GeneratorInfo;
@@ -41,8 +42,7 @@ pub(crate) struct ApiDartOutputSpecItem {
     pub classes: Vec<ApiDartGeneratedClass>,
     pub imports: DartBasicHeaderCode,
     pub preamble: String,
-    pub unused_types: Vec<String>,
-    pub skipped_functions: Vec<String>,
+    pub skips: Vec<MirSkip>,
     pub needs_freezed: bool,
 }
 
@@ -125,25 +125,31 @@ fn generate_item(
 
     sanity_check_class_name_duplicates(&classes)?;
 
-    let unused_types = (context.mir_pack.unused_types.iter())
-        .filter(|t| &t.namespace == namespace)
-        .map(|t| t.name.to_owned())
-        .collect_vec();
-
-    let skipped_functions = (context.mir_pack.skipped_functions.iter())
-        .filter(|t| &t.namespace == namespace)
-        .map(|t| t.name.to_owned())
-        .collect_vec();
-
     let needs_freezed = classes.iter().any(|class| class.needs_freezed);
 
     Ok(ApiDartOutputSpecItem {
         funcs,
         classes,
         imports,
         preamble: context.config.dart_preamble.clone(),
-        unused_types,
-        skipped_functions,
+        skips: compute_skips(context.mir_pack, namespace),
         needs_freezed,
     })
 }
+
+fn compute_skips(mir_pack: &MirPack, namespace: &Namespace) -> Vec<MirSkip> {
+    let unused_types = (mir_pack.unused_types.iter())
+        .filter(|t| &t.namespace == namespace)
+        .map(|name| MirSkip {
+            name: name.clone(),
+            reason: MirSkipReason::IgnoredTypeNotUsedByPub,
+        })
+        .collect_vec();
+
+    let skipped_functions = (mir_pack.skipped_functions.iter())
+        .filter(|t| &t.name.namespace == namespace)
+        .cloned()
+        .collect_vec();
+
+    concat([unused_types, skipped_functions])
+}