Generate impl blocks for associated enum functions

src/analysis/enums.rs

@@ -0,0 +1,123 @@
+use super::{function_parameters::TransformationType, imports::Imports, *};
+use crate::{config::gobjects::GObject, env::Env, nameutil::*, traits::*};
+
+use log::info;
+
+#[derive(Debug, Default)]
+pub struct Info {
+    pub full_name: String,
+    pub type_id: library::TypeId,
+    pub name: String,
+    pub functions: Vec<functions::Info>,
+    pub specials: special_functions::Infos,
+}
+
+impl Info {
+    pub fn type_<'a>(&self, library: &'a library::Library) -> &'a library::Enumeration {
+        let type_ = library
+            .type_(self.type_id)
+            .maybe_ref()
+            .unwrap_or_else(|| panic!("{} is not an enumeration.", self.full_name));
+        type_
+    }
+}
+
+pub fn new(env: &Env, obj: &GObject, imports: &mut Imports) -> Option<Info> {
+    info!("Analyzing enumeration {}", obj.name);
+
+    if !obj.status.need_generate() {
+        return None;
+    }
+
+    if !obj
+        .type_id
+        .map_or(false, |tid| tid.ns_id == namespaces::MAIN)
+    {
+        return None;
+    }
+
+    let enumeration_tid = env.library.find_type(0, &obj.name)?;
+    let type_ = env.type_(enumeration_tid);
+    let enumeration: &library::Enumeration = type_.maybe_ref()?;
+
+    let name = split_namespace_name(&obj.name).1;
+
+    // Mark the type as available within the enum namespace:
+    imports.add_defined(&format!("crate::{}", name));
+
+    let has_get_quark = enumeration.error_domain.is_some();
+    if has_get_quark {
+        imports.add("glib::Quark");
+        imports.add("glib::error::ErrorDomain");
+    }
+
+    let has_get_type = enumeration.glib_get_type.is_some();
+    if has_get_type {
+        imports.add("glib::Type");
+        imports.add("glib::StaticType");
+        imports.add("glib::value::SetValue");
+        imports.add("glib::value::FromValue");
+        imports.add("glib::value::FromValueOptional");
+    }
+
+    if obj.generate_display_trait {
+        imports.add("std::fmt");
+    }
+
+    let mut functions = functions::analyze(
+        env,
+        &enumeration.functions,
+        enumeration_tid,
+        false,
+        false,
+        obj,
+        imports,
+        None,
+        None,
+    );
+
+    // Gir does not currently mark the first parameter of associated enum functions -
+    // that are identical to its enum type - as instance parameter since most languages
+    // do not support this.
+    for f in &mut functions {
+        if f.parameters.c_parameters.is_empty() {
+            continue;
+        }
+
+        let first_param = &mut f.parameters.c_parameters[0];
+
+        if first_param.typ == enumeration_tid {
+            first_param.instance_parameter = true;
+
+            let t = f
+                .parameters
+                .transformations
+                .iter_mut()
+                .find(|t| t.ind_c == 0)
+                .unwrap();
+
+            if let TransformationType::ToGlibScalar { name, .. } = &mut t.transformation_type {
+                *name = "self".to_owned();
+            } else {
+                panic!(
+                    "Enumeration function instance param must be passed as scalar, not {:?}",
+                    t.transformation_type
+                );
+            }
+        }
+    }
+
+    let specials = special_functions::extract(&mut functions, type_, obj);
+
+    special_functions::analyze_imports(&specials, imports);
+
+    let info = Info {
+        full_name: obj.name.clone(),
+        type_id: enumeration_tid,
+        name: name.to_owned(),
+        functions,
+        specials,
+    };
+
+    Some(info)
+}

src/analysis/flags.rs

@@ -0,0 +1,117 @@
+use super::{function_parameters::TransformationType, imports::Imports, *};
+use crate::{config::gobjects::GObject, env::Env, nameutil::*, traits::*};
+
+use log::info;
+
+#[derive(Debug, Default)]
+pub struct Info {
+    pub full_name: String,
+    pub type_id: library::TypeId,
+    pub name: String,
+    pub functions: Vec<functions::Info>,
+    pub specials: special_functions::Infos,
+}
+
+impl Info {
+    pub fn type_<'a>(&self, library: &'a library::Library) -> &'a library::Bitfield {
+        let type_ = library
+            .type_(self.type_id)
+            .maybe_ref()
+            .unwrap_or_else(|| panic!("{} is not an flags.", self.full_name));
+        type_
+    }
+}
+
+pub fn new(env: &Env, obj: &GObject, imports: &mut Imports) -> Option<Info> {
+    info!("Analyzing flags {}", obj.name);
+
+    if !obj.status.need_generate() {
+        return None;
+    }
+
+    if !obj
+        .type_id
+        .map_or(false, |tid| tid.ns_id == namespaces::MAIN)
+    {
+        return None;
+    }
+
+    let flags_tid = env.library.find_type(0, &obj.name)?;
+    let type_ = env.type_(flags_tid);
+    let flags: &library::Bitfield = type_.maybe_ref()?;
+
+    let name = split_namespace_name(&obj.name).1;
+
+    // Mark the type as available within the bitfield namespace:
+    imports.add_defined(&format!("crate::{}", name));
+
+    let has_get_type = flags.glib_get_type.is_some();
+    if has_get_type {
+        imports.add("glib::Type");
+        imports.add("glib::StaticType");
+        imports.add("glib::value::SetValue");
+        imports.add("glib::value::FromValue");
+        imports.add("glib::value::FromValueOptional");
+    }
+
+    if obj.generate_display_trait {
+        imports.add("std::fmt");
+    }
+
+    let mut functions = functions::analyze(
+        env,
+        &flags.functions,
+        flags_tid,
+        false,
+        false,
+        obj,
+        imports,
+        None,
+        None,
+    );
+
+    // Gir does not currently mark the first parameter of associated bitfield functions -
+    // that are identical to its bitfield type - as instance parameter since most languages
+    // do not support this.
+    for f in &mut functions {
+        if f.parameters.c_parameters.is_empty() {
+            continue;
+        }
+
+        let first_param = &mut f.parameters.c_parameters[0];
+
+        if first_param.typ == flags_tid {
+            first_param.instance_parameter = true;
+
+            let t = f
+                .parameters
+                .transformations
+                .iter_mut()
+                .find(|t| t.ind_c == 0)
+                .unwrap();
+
+            if let TransformationType::ToGlibScalar { name, .. } = &mut t.transformation_type {
+                *name = "self".to_owned();
+            } else {
+                panic!(
+                    "Bitfield function instance param must be passed as scalar, not {:?}",
+                    t.transformation_type
+                );
+            }
+        }
+    }
+
+    let specials = special_functions::extract(&mut functions, type_, obj);
+
+    special_functions::analyze_imports(&specials, imports);
+
+    let info = Info {
+        full_name: obj.name.clone(),
+        type_id: flags_tid,
+        name: name.to_owned(),
+        functions,
+        specials,
+    };
+
+    Some(info)
+}

src/analysis/function_parameters.rs

@@ -375,11 +375,8 @@ fn is_length(par: &library::Parameter) -> bool {
     if len >= 3 && &par.name[len - 3..len] == "len" {
         return true;
     }
-    if par.name.find("length").is_some() {
-        return true;
-    }
 
-    false
+    par.name.contains("length")
 }
 
 fn has_length(env: &Env, typ: TypeId) -> bool {

src/analysis/functions.rs

@@ -845,7 +845,7 @@ fn analyze_async(
     }) = callback_info
     {
         // Checks for /*Ignored*/ or other error comments
-        *commented |= callback_type.find("/*").is_some();
+        *commented |= callback_type.contains("/*");
         let func_name = func.c_identifier.as_ref().unwrap();
         let finish_func_name = finish_function_name(func_name);
         let mut output_params = vec![];

src/analysis/imports.rs

@@ -3,6 +3,7 @@ use crate::{library::Library, nameutil::crate_name, version::Version};
 use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::btree_map::BTreeMap;
+use std::collections::HashSet;
 use std::ops::{Deref, DerefMut};
 use std::vec::IntoIter;
 
@@ -70,10 +71,8 @@ fn compare_imports(a: &(&String, &ImportConditions), b: &(&String, &ImportCondit
 pub struct Imports {
     /// Name of the current crate.
     crate_name: String,
-    /// Name defined within current module. It doesn't need use declaration.
-    ///
-    /// NOTE: Currently we don't need to support more than one such name.
-    defined: Option<String>,
+    /// Names defined within current module. It doesn't need use declaration.
+    defined: HashSet<String>,
     defaults: ImportConditions,
     map: BTreeMap<String, ImportConditions>,
 }
@@ -82,7 +81,7 @@ impl Imports {
     pub fn new(gir: &Library) -> Imports {
         Imports {
             crate_name: make_crate_name(gir),
-            defined: None,
+            defined: HashSet::new(),
             defaults: ImportConditions::default(),
             map: BTreeMap::new(),
         }
@@ -91,7 +90,7 @@ impl Imports {
     pub fn with_defined(gir: &Library, name: &str) -> Imports {
         Imports {
             crate_name: make_crate_name(gir),
-            defined: Some(name.to_owned()),
+            defined: std::iter::once(name.to_owned()).collect(),
             defaults: ImportConditions::default(),
             map: BTreeMap::new(),
         }
@@ -120,19 +119,32 @@ impl Imports {
         self.defaults.clear();
     }
 
-    /// The goals of this function is to discard unwanted imports like "ffi" and "crate". It
+    /// The goals of this function is to discard unwanted imports like "crate". It
     /// also extends the checks in case you are implementing "X". For example, you don't want to
     /// import "X" or "crate::X" in this case.
     fn common_checks(&self, name: &str) -> bool {
-        if name == "crate::ffi" || (!name.contains("::") && name != "xlib") {
+        // The ffi namespace is used directly, including it is a programmer error.
+        assert_ne!(name, "crate::ffi");
+
+        if (!name.contains("::") && name != "xlib") || self.defined.contains(name) {
             false
-        } else if let Some(ref defined) = self.defined {
-            !((name.starts_with("crate::") && &name[7..] == defined) || name == defined)
+        } else if let Some(name) = name.strip_prefix("crate::") {
+            !self.defined.contains(name)
         } else {
             true
         }
     }
 
+    /// Declares that `name` is defined in scope
+    ///
+    /// Removes existing imports from `self.map` and marks `name` as
+    /// available to counter future import "requests".
+    pub fn add_defined(&mut self, name: &str) {
+        if self.defined.insert(name.to_owned()) {
+            self.map.remove(name);
+        }
+    }
+
     /// Declares that name should be available through its last path component.
     ///
     /// For example, if name is `X::Y::Z` then it will be available as `Z`.