enums: Merge import dict in codegen

src/analysis/enums.rs

@@ -34,7 +34,7 @@ impl Info {
     }
 }
 
-pub fn new(env: &Env, obj: &GObject, imports: &mut Imports) -> Option<Info> {
+pub fn new(env: &Env, obj: &GObject) -> Option<Info> {
     info!("Analyzing enumeration {}", obj.name);
 
     if !obj.status.need_generate() {
@@ -54,11 +54,13 @@ pub fn new(env: &Env, obj: &GObject, imports: &mut Imports) -> Option<Info> {
 
     let name = split_namespace_name(&obj.name).1;
 
+    let mut imports = Imports::new(&env.library);
+    imports.add("glib::translate::*");
+    imports.add(env.main_sys_crate_name());
+
     // Mark the type as available within the enum namespace:
     imports.add_defined(name);
 
-    imports.add(env.main_sys_crate_name());
-
     let has_get_quark = enumeration.error_domain.is_some();
     if has_get_quark {
         imports.add("glib::Quark");
@@ -87,7 +89,7 @@ pub fn new(env: &Env, obj: &GObject, imports: &mut Imports) -> Option<Info> {
         false,
         false,
         obj,
-        imports,
+        &mut imports,
         None,
         None,
     );
@@ -135,7 +137,7 @@ pub fn new(env: &Env, obj: &GObject, imports: &mut Imports) -> Option<Info> {
 
     let specials = special_functions::extract(&mut functions);
 
-    special_functions::analyze_imports(&specials, imports);
+    special_functions::analyze_imports(&specials, &mut imports);
 
     let (version, deprecated_version) = info_base::versions(
         env,
@@ -151,8 +153,7 @@ pub fn new(env: &Env, obj: &GObject, imports: &mut Imports) -> Option<Info> {
         name: name.to_owned(),
         functions,
         specials,
-        // TODO: Don't use!
-        imports: Imports::new(&env.library),
+        imports,
         version,
         deprecated_version,
         cfg_condition: obj.cfg_condition.clone(),

src/analysis/imports.rs

@@ -118,6 +118,36 @@ impl Imports {
         self.defaults.clear();
     }
 
+    pub fn merge<'a>(imports: impl Iterator<Item = &'a Self>) -> Self {
+        let mut defined = HashSet::new();
+        let mut map = BTreeMap::new();
+
+        let mut crate_name = None;
+
+        for i in imports {
+            if let Some(n) = crate_name {
+                assert_eq!(n, &i.crate_name);
+            } else {
+                crate_name = Some(&i.crate_name);
+            }
+
+            defined.extend(i.defined.clone());
+            map.extend(i.map.clone());
+        }
+
+        for d in &defined {
+            map.remove(d);
+        }
+
+        Self {
+            crate_name: crate_name.unwrap().clone(),
+            defined,
+            map,
+            // TODO: Merge import conditions
+            defaults: ImportConditions::default(),
+        }
+    }
+
     /// Declares that `name` is defined in scope
     ///
     /// Removes existing imports from `self.map` and marks `name` as

src/analysis/mod.rs

@@ -47,7 +47,6 @@ pub struct Analysis {
     pub global_functions: Option<info_base::InfoBase>,
     pub constants: Vec<constants::Info>,
     pub enumerations: Vec<enums::Info>,
-    pub enum_imports: Imports,
 }
 
 pub fn run(env: &mut Env) {
@@ -64,10 +63,6 @@ pub fn run(env: &mut Env) {
         to_analyze.push((tid, deps));
     }
 
-    let mut enum_imports = Imports::new(&env.library);
-    enum_imports.add("glib::translate::*");
-    enum_imports.add(env.main_sys_crate_name());
-
     let mut analyzed = 1;
     while analyzed > 0 {
         analyzed = 0;
@@ -77,15 +72,13 @@ pub fn run(env: &mut Env) {
                 new_to_analyze.push((tid, deps.clone()));
                 continue;
             }
-            analyze(env, tid, deps, &mut enum_imports);
+            analyze(env, tid, deps);
             analyzed += 1;
         }
 
         to_analyze = new_to_analyze;
     }
 
-    env.analysis.enum_imports = enum_imports;
-
     if !to_analyze.is_empty() {
         error!(
             "Not analyzed {} objects due unfinished dependencies",
@@ -163,7 +156,7 @@ fn analyze_constants(env: &mut Env) {
     env.analysis.constants = constants::analyze(env, &constants, obj);
 }
 
-fn analyze(env: &mut Env, tid: TypeId, deps: &[TypeId], enum_imports: &mut Imports) {
+fn analyze(env: &mut Env, tid: TypeId, deps: &[TypeId]) {
     let full_name = tid.full_name(&env.library);
     let obj = match env.config.objects.get(&*full_name) {
         Some(obj) => obj,
@@ -187,7 +180,7 @@ fn analyze(env: &mut Env, tid: TypeId, deps: &[TypeId], enum_imports: &mut Impor
         }
         Type::Enumeration(_) => {
             // Cannot mutably borrow env.analysis.enum_imports here
-            if let Some(info) = enums::new(env, obj, enum_imports) {
+            if let Some(info) = enums::new(env, obj) {
                 env.analysis.enumerations.push(info);
             }
         }

src/codegen/enums.rs

@@ -24,10 +24,14 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
         return;
     }
 
+    let imports = crate::analysis::imports::Imports::merge(
+        env.analysis.enumerations.iter().map(|e| &e.imports),
+    );
+
     let path = root_path.join("enums.rs");
     file_saver::save_to_file(path, env.config.make_backup, |w| {
         general::start_comments(w, &env.config)?;
-        general::uses(w, env, &env.analysis.enum_imports)?;
+        general::uses(w, env, &imports)?;
         writeln!(w)?;
 
         mod_rs.push("\nmod enums;".into());