diff --git a/Cargo.lock b/Cargo.lock index e7f61888a..03715756a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -154,9 +154,9 @@ source = "git+https://github.com/GuillaumeGomez/rustdoc-stripper#bbdf0a350a85c8d [[package]] name = "serde" -version = "1.0.117" +version = "1.0.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a" +checksum = "06c64263859d87aa2eb554587e2d23183398d617427327cf2b3d0ed8c69e4800" [[package]] name = "thread_local" diff --git a/src/analysis/enums.rs b/src/analysis/enums.rs new file mode 100644 index 000000000..ace41d290 --- /dev/null +++ b/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, + 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!("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) +} diff --git a/src/analysis/flags.rs b/src/analysis/flags.rs new file mode 100644 index 000000000..e04f73698 --- /dev/null +++ b/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, + 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!("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) +} diff --git a/src/analysis/function_parameters.rs b/src/analysis/function_parameters.rs index 54c207a08..1572de778 100644 --- a/src/analysis/function_parameters.rs +++ b/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 { diff --git a/src/analysis/functions.rs b/src/analysis/functions.rs index 401a038b2..ff4843a86 100644 --- a/src/analysis/functions.rs +++ b/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![]; diff --git a/src/analysis/imports.rs b/src/analysis/imports.rs index 87be8c08c..6b2cc63e1 100644 --- a/src/analysis/imports.rs +++ b/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, + /// Names defined within current module. It doesn't need use declaration. + defined: HashSet, defaults: ImportConditions, map: BTreeMap, } @@ -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`. diff --git a/src/analysis/mod.rs b/src/analysis/mod.rs index 512fac459..c540fd4b6 100644 --- a/src/analysis/mod.rs +++ b/src/analysis/mod.rs @@ -2,6 +2,7 @@ use crate::{ env::Env, library::{self, Type, TypeId}, }; +use imports::Imports; use log::error; use std::collections::BTreeMap; @@ -12,7 +13,9 @@ pub mod class_builder; pub mod class_hierarchy; pub mod constants; pub mod conversion_type; +pub mod enums; pub mod ffi_type; +pub mod flags; pub mod function_parameters; pub mod functions; pub mod general; @@ -44,6 +47,11 @@ pub struct Analysis { pub records: BTreeMap, pub global_functions: Option, pub constants: Vec, + pub enumerations: Vec, + pub enum_imports: Imports, + + pub flags: Vec, + pub flags_imports: Imports, } pub fn run(env: &mut Env) { @@ -75,6 +83,7 @@ pub fn run(env: &mut Env) { to_analyze = new_to_analyze; } + if !to_analyze.is_empty() { error!( "Not analyzed {} objects due unfinished dependencies", @@ -83,12 +92,63 @@ pub fn run(env: &mut Env) { return; } + analyze_enums(env); + + analyze_flags(env); + analyze_constants(env); // Analyze free functions as the last step once all types are analyzed analyze_global_functions(env); } +fn analyze_enums(env: &mut Env) { + let mut imports = Imports::new(&env.library); + imports.add("glib::translate::*"); + + for obj in env.config.objects.values() { + if obj.status.ignored() { + continue; + } + let tid = match env.library.find_type(0, &obj.name) { + Some(x) => x, + None => continue, + }; + + if let Type::Enumeration(_) = env.library.type_(tid) { + if let Some(info) = enums::new(env, obj, &mut imports) { + env.analysis.enumerations.push(info); + } + } + } + + env.analysis.enum_imports = imports; +} + +fn analyze_flags(env: &mut Env) { + let mut imports = Imports::new(&env.library); + imports.add("glib::translate::*"); + imports.add("bitflags::bitflags"); + + for obj in env.config.objects.values() { + if obj.status.ignored() { + continue; + } + let tid = match env.library.find_type(0, &obj.name) { + Some(x) => x, + None => continue, + }; + + if let Type::Bitfield(_) = env.library.type_(tid) { + if let Some(info) = flags::new(env, obj, &mut imports) { + env.analysis.flags.push(info); + } + } + } + + env.analysis.flags_imports = imports; +} + fn analyze_global_functions(env: &mut Env) { let ns = env.library.namespace(library::MAIN_NAMESPACE); @@ -110,7 +170,6 @@ fn analyze_global_functions(env: &mut Env) { let mut imports = imports::Imports::new(&env.library); imports.add("glib::translate::*"); - imports.add(&format!("crate::{}", env.main_sys_crate_name())); let functions = functions::analyze( env, diff --git a/src/analysis/object.rs b/src/analysis/object.rs index 45cb59b2b..7bc6f8cce 100644 --- a/src/analysis/object.rs +++ b/src/analysis/object.rs @@ -62,7 +62,6 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option let mut imports = Imports::with_defined(&env.library, &name); imports.add("glib::translate::*"); - imports.add(&format!("crate::{}", env.main_sys_crate_name())); if obj.generate_display_trait { imports.add("std::fmt"); } @@ -89,7 +88,7 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option Some(&mut signatures), Some(deps), ); - let mut specials = special_functions::extract(&mut functions); + let mut specials = special_functions::extract(&mut functions, type_, obj); // `copy` will duplicate an object while `clone` just adds a reference special_functions::unhide(&mut functions, &specials, special_functions::Type::Copy); // these are all automatically derived on objects and compare by pointer. If such functions @@ -98,10 +97,9 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option special_functions::Type::Hash, special_functions::Type::Equal, special_functions::Type::Compare, - special_functions::Type::ToString, ] { special_functions::unhide(&mut functions, &specials, *t); - specials.remove(t); + specials.traits_mut().remove(t); } special_functions::analyze_imports(&specials, &mut imports); @@ -230,7 +228,6 @@ pub fn interface(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option Option { let is_boxed = obj.use_boxed_functions || RecordType::of(&record) == RecordType::AutoBoxed; let mut imports = Imports::with_defined(&env.library, &name); - imports.add(&format!("crate::{}", env.main_sys_crate_name())); let mut functions = functions::analyze( env, @@ -93,7 +92,7 @@ pub fn new(env: &Env, obj: &GObject) -> Option { None, None, ); - let specials = special_functions::extract(&mut functions); + let specials = special_functions::extract(&mut functions, type_, obj); let (version, deprecated_version) = info_base::versions( env, @@ -103,8 +102,8 @@ pub fn new(env: &Env, obj: &GObject) -> Option { record.deprecated_version, ); - let is_shared = specials.get(&special_functions::Type::Ref).is_some() - && specials.get(&special_functions::Type::Unref).is_some(); + let is_shared = specials.has_trait(special_functions::Type::Ref) + && specials.has_trait(special_functions::Type::Unref); if is_shared { // `copy` will duplicate a struct while `clone` just adds a reference special_functions::unhide(&mut functions, &specials, special_functions::Type::Copy); @@ -128,7 +127,7 @@ pub fn new(env: &Env, obj: &GObject) -> Option { derives }; - for special in specials.keys() { + for special in specials.traits().keys() { match special { special_functions::Type::Compare => { derives = filter_derives(&derives, &["PartialOrd", "Ord", "PartialEq", "Eq"]); @@ -161,10 +160,9 @@ pub fn new(env: &Env, obj: &GObject) -> Option { // Check if we have to make use of the GType and the generic // boxed functions. if obj.use_boxed_functions - || ((specials.get(&special_functions::Type::Ref).is_none() - || specials.get(&special_functions::Type::Unref).is_none()) - && (specials.get(&special_functions::Type::Copy).is_none() - || specials.get(&special_functions::Type::Free).is_none())) + || !is_shared + && (!specials.has_trait(special_functions::Type::Copy) + || !specials.has_trait(special_functions::Type::Free)) { if let Some((_, get_type_version)) = glib_get_type { if get_type_version > version { diff --git a/src/analysis/signals.rs b/src/analysis/signals.rs index dd8bdfb58..84f0c43f3 100644 --- a/src/analysis/signals.rs +++ b/src/analysis/signals.rs @@ -47,9 +47,7 @@ pub fn analyze( obj, imports, ); - if let Some(info) = info { - sns.push(info); - } + sns.push(info); } sns @@ -63,7 +61,7 @@ fn analyze_signal( configured_signals: &[&config::signals::Signal], obj: &GObject, imports: &mut Imports, -) -> Option { +) -> Info { let mut used_types: Vec = Vec::with_capacity(4); let version = configured_signals .iter() @@ -117,5 +115,6 @@ fn analyze_signal( deprecated_version, doc_hidden, }; - Some(info) + + info } diff --git a/src/analysis/special_functions.rs b/src/analysis/special_functions.rs index 5849828b7..3f7aaca06 100644 --- a/src/analysis/special_functions.rs +++ b/src/analysis/special_functions.rs @@ -1,6 +1,11 @@ -use crate::analysis::{ - functions::{Info as FuncInfo, Visibility}, - imports::Imports, +use crate::{ + analysis::{ + functions::{Info as FuncInfo, Visibility}, + imports::Imports, + }, + config::GObject, + library::{Type as LibType, TypeId}, + version::Version, }; use std::{collections::BTreeMap, str::FromStr}; @@ -11,7 +16,7 @@ pub enum Type { Equal, Free, Ref, - ToString, + Display, Unref, Hash, } @@ -19,7 +24,7 @@ pub enum Type { impl FromStr for Type { type Err = String; - fn from_str(s: &str) -> Result { + fn from_str(s: &str) -> Result { use self::Type::*; match s { "compare" => Ok(Compare), @@ -28,7 +33,6 @@ impl FromStr for Type { "free" | "destroy" => Ok(Free), "is_equal" => Ok(Equal), "ref" | "ref_" => Ok(Ref), - "to_string" => Ok(ToString), "unref" => Ok(Unref), "hash" => Ok(Hash), _ => Err(format!("Unknown type '{}'", s)), @@ -36,32 +40,142 @@ impl FromStr for Type { } } -pub type Infos = BTreeMap; // Type => glib_name +#[derive(Debug, Clone)] +pub struct TraitInfo { + pub glib_name: String, + pub version: Option, +} -fn update_func(func: &mut FuncInfo, type_: Type) -> bool { - if func.visibility != Visibility::Comment { - func.visibility = visibility(type_, func.parameters.c_parameters.len()); +type TraitInfos = BTreeMap; + +#[derive(Clone, Copy, Eq, Debug, Ord, PartialEq, PartialOrd)] +pub enum FunctionType { + StaticStringify, +} + +#[derive(Debug, Clone)] +pub struct FunctionInfo { + pub type_: FunctionType, + pub version: Option, +} + +type FunctionInfos = BTreeMap; + +#[derive(Debug, Default)] +pub struct Infos { + traits: TraitInfos, + functions: FunctionInfos, +} + +impl Infos { + pub fn traits(&self) -> &TraitInfos { + &self.traits } - // I assume `to_string` functions never return `NULL` - if type_ == Type::ToString { - if let Some(par) = func.ret.parameter.as_mut() { - *par.nullable = false; - } - if func.visibility != Visibility::Private { + + pub fn traits_mut(&mut self) -> &mut TraitInfos { + &mut self.traits + } + + pub fn has_trait(&self, type_: Type) -> bool { + self.traits.contains_key(&type_) + } + + pub fn functions(&self) -> &FunctionInfos { + &self.functions + } +} + +/// Returns true on functions that take an instance as single argument and +/// return a string as result. +fn is_stringify(func: &mut FuncInfo, parent_type: &LibType, obj: &GObject) -> bool { + if func.parameters.c_parameters.len() != 1 { + return false; + } + if !func.parameters.c_parameters[0].instance_parameter { + return false; + } + + if let Some(ret) = func.ret.parameter.as_mut() { + if ret.typ != TypeId::tid_utf8() { return false; } + + if func.name == "to_string" { + // Rename to to_str to make sure it doesn't clash with ToString::to_string + func.name = "to_str".to_owned(); + + // As to not change old code behaviour, assume non-nullability outside + // enums and flags only, and exclusively for to_string. Function inside + // enums and flags have been appropriately marked in Gir. + if !obj.trust_return_value_nullability + && !matches!(parent_type, LibType::Enumeration(_) | LibType::Bitfield(_)) + { + *ret.nullable = false; + } + } + + // Cannot generate Display implementation for Option<> + !*ret.nullable + } else { + false + } +} + +fn update_func(func: &mut FuncInfo, type_: Type) -> bool { + if func.visibility != Visibility::Comment { + func.visibility = visibility(type_); } true } -pub fn extract(functions: &mut Vec) -> Infos { - let mut specials = BTreeMap::new(); +pub fn extract(functions: &mut Vec, parent_type: &LibType, obj: &GObject) -> Infos { + let mut specials = Infos::default(); let mut has_copy = false; let mut has_free = false; let mut destroy = None; for (pos, func) in functions.iter_mut().enumerate() { - if let Ok(type_) = Type::from_str(&func.name) { + if is_stringify(func, parent_type, obj) { + let return_transfer_none = func + .ret + .parameter + .as_ref() + .map_or(false, |ret| ret.transfer == crate::library::Transfer::None); + + // Assume only enumerations and bitfields can return static strings + let returns_static_ref = return_transfer_none + && matches!(parent_type, LibType::Enumeration(_) | LibType::Bitfield(_)) + // We cannot mandate returned lifetime if this is not generated. + // (And this prevents an unused std::ffi::CStr from being emitted below) + && func.status.need_generate(); + + if returns_static_ref { + // Override the function with a &'static (non allocating) -returning string + // if the transfer type is none and it matches the above heuristics. + specials.functions.insert( + func.glib_name.clone(), + FunctionInfo { + type_: FunctionType::StaticStringify, + version: func.version, + }, + ); + } + + // Some stringifying functions can serve as Display implementation + if matches!( + func.name.as_str(), + "to_string" | "to_str" | "name" | "get_name" + ) { + // FUTURE: Decide which function gets precedence if multiple Display prospects exist. + specials.traits.insert( + Type::Display, + TraitInfo { + glib_name: func.glib_name.clone(), + version: func.version, + }, + ); + } + } else if let Ok(type_) = func.name.parse() { if func.name == "destroy" { destroy = Some((func.glib_name.clone(), pos)); continue; @@ -74,37 +188,50 @@ pub fn extract(functions: &mut Vec) -> Infos { } else if func.name == "free" { has_free = true; } - specials.insert(type_, func.glib_name.clone()); + + specials.traits.insert( + type_, + TraitInfo { + glib_name: func.glib_name.clone(), + version: func.version, + }, + ); } } if has_copy && !has_free { if let Some((glib_name, pos)) = destroy { let ty_ = Type::from_str("destroy").unwrap(); - update_func(&mut functions[pos], ty_); - specials.insert(ty_, glib_name); + let func = &mut functions[pos]; + update_func(func, ty_); + specials.traits.insert( + ty_, + TraitInfo { + glib_name, + version: func.version, + }, + ); } } specials } -fn visibility(t: Type, args_len: usize) -> Visibility { +fn visibility(t: Type) -> Visibility { use self::Type::*; match t { Copy | Free | Ref | Unref => Visibility::Hidden, Hash | Compare | Equal => Visibility::Private, - ToString if args_len == 1 => Visibility::Private, - ToString => Visibility::Public, + Display => Visibility::Public, } } // Some special functions (e.g. `copy` on refcounted types) should be exposed pub fn unhide(functions: &mut Vec, specials: &Infos, type_: Type) { - if let Some(func) = specials.get(&type_) { + if let Some(func) = specials.traits().get(&type_) { let func = functions .iter_mut() - .find(|f| f.glib_name == *func && f.visibility != Visibility::Comment); + .find(|f| f.glib_name == func.glib_name && f.visibility != Visibility::Comment); if let Some(func) = func { func.visibility = Visibility::Public; } @@ -112,13 +239,20 @@ pub fn unhide(functions: &mut Vec, specials: &Infos, type_: Type) { } pub fn analyze_imports(specials: &Infos, imports: &mut Imports) { - use self::Type::*; - for type_ in specials.keys() { + for (type_, info) in specials.traits() { + use self::Type::*; match *type_ { - Compare => imports.add("std::cmp"), - ToString => imports.add("std::fmt"), - Hash => imports.add("std::hash"), + Compare => imports.add_with_version("std::cmp", info.version), + Display => imports.add_with_version("std::fmt", info.version), + Hash => imports.add_with_version("std::hash", info.version), _ => {} } } + for info in specials.functions().values() { + match info.type_ { + FunctionType::StaticStringify => { + imports.add_with_version("std::ffi::CStr", info.version) + } + } + } } diff --git a/src/codegen/constants.rs b/src/codegen/constants.rs index 7a63ade34..9a6ba6db4 100644 --- a/src/codegen/constants.rs +++ b/src/codegen/constants.rs @@ -17,7 +17,6 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec) { } let sys_crate_name = env.main_sys_crate_name(); - imports.add(&format!("crate::{}", sys_crate_name)); imports.add("std::ffi::CStr"); file_saver::save_to_file(path, env.config.make_backup, |w| { diff --git a/src/codegen/enums.rs b/src/codegen/enums.rs index 2e03c77e4..9a53147c2 100644 --- a/src/codegen/enums.rs +++ b/src/codegen/enums.rs @@ -1,5 +1,7 @@ +use super::{function, trait_impls}; use crate::{ - analysis::{imports::Imports, namespaces}, + analysis::enums::Info, + analysis::special_functions::Type, codegen::general::{ self, cfg_deprecated, derives, version_condition, version_condition_no_doc, version_condition_string, @@ -19,73 +21,26 @@ use std::{ }; pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec) { - let configs: Vec<&GObject> = env - .config - .objects - .values() - .filter(|c| { - c.status.need_generate() && c.type_id.map_or(false, |tid| tid.ns_id == namespaces::MAIN) - }) - .collect(); - let mut has_get_quark = false; - let mut has_any = false; - let mut has_get_type = false; - let mut generate_display_trait = false; - for config in &configs { - if let Type::Enumeration(ref enum_) = *env.library.type_(config.type_id.unwrap()) { - has_any = true; - if enum_.error_domain.is_some() { - has_get_quark = true; - } - if enum_.glib_get_type.is_some() { - has_get_type = true; - } - generate_display_trait |= config.generate_display_trait; - - if has_get_type && has_get_quark { - break; - } - } - } - - if !has_any { + if env.analysis.enumerations.is_empty() { return; } - let mut imports = Imports::new(&env.library); - imports.add(&format!("crate::{}", env.main_sys_crate_name())); - if has_get_quark { - imports.add("glib::Quark"); - imports.add("glib::error::ErrorDomain"); - } - 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"); - } - imports.add("glib::translate::*"); - - if generate_display_trait { - imports.add("std::fmt"); - } - 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, &imports)?; + general::uses(w, env, &env.analysis.enum_imports)?; writeln!(w)?; mod_rs.push("\nmod enums;".into()); - for config in &configs { - if let Type::Enumeration(ref enum_) = *env.library.type_(config.type_id.unwrap()) { - if let Some(cfg) = version_condition_string(env, enum_.version, false, 0) { - mod_rs.push(cfg); - } - mod_rs.push(format!("pub use self::enums::{};", enum_.name)); - generate_enum(env, w, enum_, config)?; + for enum_analysis in &env.analysis.enumerations { + let config = &env.config.objects[&enum_analysis.full_name]; + let enum_ = enum_analysis.type_(&env.library); + + if let Some(cfg) = version_condition_string(env, enum_.version, false, 0) { + mod_rs.push(cfg); } + mod_rs.push(format!("pub use self::enums::{};", enum_.name)); + generate_enum(env, w, enum_, config, enum_analysis)?; } Ok(()) @@ -98,6 +53,7 @@ fn generate_enum( w: &mut dyn Write, enum_: &Enumeration, config: &GObject, + analysis: &Info, ) -> Result<()> { struct Member { name: String, @@ -158,11 +114,45 @@ fn generate_enum( "\ #[doc(hidden)] __Unknown(i32), -}} -" +}}" )?; - if config.generate_display_trait { + let functions = analysis + .functions + .iter() + .filter(|f| f.status.need_generate()) + .collect::>(); + + if !functions.is_empty() { + writeln!(w)?; + version_condition(w, env, enum_.version, false, 0)?; + write!(w, "impl {} {{", analysis.name)?; + for func_analysis in functions { + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + false, + false, + 1, + )?; + } + writeln!(w, "}}")?; + } + + trait_impls::generate( + w, + env, + &analysis.name, + &analysis.functions, + &analysis.specials, + None, + )?; + + writeln!(w)?; + + if config.generate_display_trait && !analysis.specials.has_trait(Type::Display) { // Generate Display trait implementation. version_condition(w, env, enum_.version, false, 0)?; writeln!( diff --git a/src/codegen/flags.rs b/src/codegen/flags.rs index fb6b8a066..ad188684c 100644 --- a/src/codegen/flags.rs +++ b/src/codegen/flags.rs @@ -1,5 +1,7 @@ +use super::{function, trait_impls}; use crate::{ - analysis::{imports::Imports, namespaces}, + analysis::flags::Info, + analysis::special_functions::Type, codegen::general::{ self, cfg_deprecated, derives, version_condition, version_condition_string, }, @@ -16,55 +18,26 @@ use std::{ }; pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec) { - let configs: Vec<&GObject> = env - .config - .objects - .values() - .filter(|c| { - c.status.need_generate() && c.type_id.map_or(false, |tid| tid.ns_id == namespaces::MAIN) - }) - .collect(); - let has_any = configs - .iter() - .any(|c| matches!(*env.library.type_(c.type_id.unwrap()), Type::Bitfield(_))); - - if !has_any { + if env.analysis.flags.is_empty() { return; } let path = root_path.join("flags.rs"); file_saver::save_to_file(path, env.config.make_backup, |w| { - let mut imports = Imports::new(&env.library); - imports.add(&format!("crate::{}", env.main_sys_crate_name())); - imports.add("glib::translate::*"); - imports.add("bitflags::bitflags"); - - for config in &configs { - if let Type::Bitfield(ref flags) = *env.library.type_(config.type_id.unwrap()) { - if flags.glib_get_type.is_some() { - imports.add("glib::Type"); - imports.add("glib::StaticType"); - imports.add("glib::value::SetValue"); - imports.add("glib::value::FromValue"); - imports.add("glib::value::FromValueOptional"); - break; - } - } - } - general::start_comments(w, &env.config)?; - general::uses(w, env, &imports)?; + general::uses(w, env, &env.analysis.flags_imports)?; writeln!(w)?; mod_rs.push("\nmod flags;".into()); - for config in &configs { - if let Type::Bitfield(ref flags) = *env.library.type_(config.type_id.unwrap()) { - if let Some(cfg) = version_condition_string(env, flags.version, false, 0) { - mod_rs.push(cfg); - } - mod_rs.push(format!("pub use self::flags::{};", flags.name)); - generate_flags(env, w, flags, config)?; + for flags_analysis in &env.analysis.flags { + let config = &env.config.objects[&flags_analysis.full_name]; + let flags = flags_analysis.type_(&env.library); + + if let Some(cfg) = version_condition_string(env, flags.version, false, 0) { + mod_rs.push(cfg); } + mod_rs.push(format!("pub use self::flags::{};", flags.name)); + generate_flags(env, w, flags, config, flags_analysis)?; } Ok(()) @@ -72,7 +45,13 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec) { } #[allow(clippy::write_literal)] -fn generate_flags(env: &Env, w: &mut dyn Write, flags: &Bitfield, config: &GObject) -> Result<()> { +fn generate_flags( + env: &Env, + w: &mut dyn Write, + flags: &Bitfield, + config: &GObject, + analysis: &Info, +) -> Result<()> { let sys_crate_name = env.main_sys_crate_name(); cfg_deprecated(w, env, flags.deprecated_version, false, 0)?; version_condition(w, env, flags.version, false, 0)?; @@ -107,12 +86,59 @@ fn generate_flags(env: &Env, w: &mut dyn Write, flags: &Bitfield, config: &GObje writeln!( w, - "{}", - " } -} -" + " }} +}}" + )?; + + let functions = analysis + .functions + .iter() + .filter(|f| f.status.need_generate()) + .collect::>(); + + if !functions.is_empty() { + writeln!(w)?; + version_condition(w, env, flags.version, false, 0)?; + write!(w, "impl {} {{", analysis.name)?; + for func_analysis in functions { + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + false, + false, + 1, + )?; + } + writeln!(w, "}}")?; + } + + trait_impls::generate( + w, + env, + &analysis.name, + &analysis.functions, + &analysis.specials, + None, )?; + writeln!(w)?; + + if config.generate_display_trait && !analysis.specials.has_trait(Type::Display) { + // Generate Display trait implementation. + version_condition(w, env, flags.version, false, 0)?; + writeln!( + w, + "impl fmt::Display for {0} {{\n\ + \tfn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {{\n\ + \t\t::fmt(self, f)\n\ + \t}}\n\ + }}\n", + flags.name + )?; + } + version_condition(w, env, flags.version, false, 0)?; writeln!( w, diff --git a/src/codegen/function.rs b/src/codegen/function.rs index 8c7ffb1ae..2330a19f6 100644 --- a/src/codegen/function.rs +++ b/src/codegen/function.rs @@ -5,6 +5,7 @@ use super::{ }, parameter::ToParameter, return_value::{out_parameters_as_return, ToReturnValue}, + special_functions, }; use crate::{ analysis::{ @@ -29,6 +30,7 @@ pub fn generate( w: &mut dyn Write, env: &Env, analysis: &analysis::functions::Info, + special_functions: Option<&analysis::special_functions::Infos>, in_trait: bool, only_declaration: bool, indent: usize, @@ -41,6 +43,12 @@ pub fn generate( return Ok(()); } + if let Some(special_functions) = special_functions { + if special_functions::generate(w, env, analysis, special_functions)? { + return Ok(()); + } + } + let mut commented = false; let mut comment_prefix = ""; let mut pub_prefix = if in_trait { "" } else { "pub " }; diff --git a/src/codegen/functions.rs b/src/codegen/functions.rs index 8575b1bfd..14cd75a15 100644 --- a/src/codegen/functions.rs +++ b/src/codegen/functions.rs @@ -24,7 +24,7 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec) { mod_rs.push("\npub mod functions;".into()); for func_analysis in &functions.functions { - function::generate(w, env, func_analysis, false, false, 0)?; + function::generate(w, env, func_analysis, None, false, false, 0)?; } Ok(()) diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs index 36bf85973..63032106b 100644 --- a/src/codegen/mod.rs +++ b/src/codegen/mod.rs @@ -21,6 +21,7 @@ mod records; mod return_value; mod signal; mod signal_body; +mod special_functions; mod sys; mod trait_impls; mod trampoline; diff --git a/src/codegen/object.rs b/src/codegen/object.rs index 9088e05a8..7191d75f5 100644 --- a/src/codegen/object.rs +++ b/src/codegen/object.rs @@ -1,5 +1,6 @@ use super::{child_properties, function, general, properties, signal, trait_impls}; use crate::{ + analysis::special_functions::Type, analysis::{ self, rust_type::{rust_type, rust_type_full}, @@ -36,12 +37,28 @@ pub fn generate( writeln!(w)?; write!(w, "impl {} {{", analysis.name)?; for func_analysis in &analysis.constructors() { - function::generate(w, env, func_analysis, false, false, 1)?; + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + false, + false, + 1, + )?; } if !need_generate_trait(analysis) { for func_analysis in &analysis.methods() { - function::generate(w, env, func_analysis, false, false, 1)?; + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + false, + false, + 1, + )?; } for property in &analysis.properties { @@ -54,7 +71,15 @@ pub fn generate( } for func_analysis in &analysis.functions() { - function::generate(w, env, func_analysis, false, false, 1)?; + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + false, + false, + 1, + )?; } if !need_generate_trait(analysis) { @@ -133,7 +158,7 @@ pub fn generate( generate_trait(w, env, analysis)?; } - if generate_display_trait { + if generate_display_trait && !analysis.specials.has_trait(Type::Display) { writeln!(w, "\nimpl fmt::Display for {} {{", analysis.name,)?; // Generate Display trait implementation. writeln!( @@ -274,7 +299,15 @@ fn generate_trait(w: &mut dyn Write, env: &Env, analysis: &analysis::object::Inf write!(w, "pub trait {}: 'static {{", analysis.trait_name)?; for func_analysis in &analysis.methods() { - function::generate(w, env, func_analysis, true, true, 1)?; + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + true, + true, + 1, + )?; } for property in &analysis.properties { properties::generate(w, env, property, true, true, 1)?; @@ -299,7 +332,15 @@ fn generate_trait(w: &mut dyn Write, env: &Env, analysis: &analysis::object::Inf )?; for func_analysis in &analysis.methods() { - function::generate(w, env, func_analysis, true, false, 1)?; + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + true, + false, + 1, + )?; } for property in &analysis.properties { properties::generate(w, env, property, true, false, 1)?; diff --git a/src/codegen/parameter.rs b/src/codegen/parameter.rs index 2744b157e..a1506ef8a 100644 --- a/src/codegen/parameter.rs +++ b/src/codegen/parameter.rs @@ -16,22 +16,22 @@ pub trait ToParameter { impl ToParameter for CParameter { fn to_parameter(&self, env: &Env, bounds: &Bounds) -> String { - let mut_str = if self.ref_mode == RefMode::ByRefMut { - "mut " - } else { - "" + let ref_str = match self.ref_mode { + RefMode::ByRefMut => "&mut ", + RefMode::None => "", + _ => "&", }; if self.instance_parameter { - format!("&{}self", mut_str) + format!("{}self", ref_str) } else { let type_str: String; match bounds.get_parameter_alias_info(&self.name) { Some((t, bound_type)) => match bound_type { BoundType::NoWrapper => type_str = t.to_string(), BoundType::IsA(_) if *self.nullable => { - type_str = format!("Option<&{}{}>", mut_str, t) + type_str = format!("Option<{}{}>", ref_str, t) } - BoundType::IsA(_) => type_str = format!("&{}{}", mut_str, t), + BoundType::IsA(_) => type_str = format!("{}{}", ref_str, t), BoundType::AsRef(_) => type_str = t.to_string(), }, None => { diff --git a/src/codegen/record.rs b/src/codegen/record.rs index 201c72355..caadae155 100644 --- a/src/codegen/record.rs +++ b/src/codegen/record.rs @@ -31,16 +31,16 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info) ); } } else if let (Some(ref_fn), Some(unref_fn)) = ( - analysis.specials.get(&Type::Ref), - analysis.specials.get(&Type::Unref), + analysis.specials.traits().get(&Type::Ref), + analysis.specials.traits().get(&Type::Unref), ) { general::define_shared_type( w, env, &analysis.name, &type_.c_type, - ref_fn, - unref_fn, + &ref_fn.glib_name, + &unref_fn.glib_name, analysis.glib_get_type.as_ref().map(|(f, v)| { if v > &analysis.version { (f.clone(), *v) @@ -51,16 +51,16 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info) &analysis.derives, )?; } else if let (Some(copy_fn), Some(free_fn)) = ( - analysis.specials.get(&Type::Copy), - analysis.specials.get(&Type::Free), + analysis.specials.traits().get(&Type::Copy), + analysis.specials.traits().get(&Type::Free), ) { general::define_boxed_type( w, env, &analysis.name, &type_.c_type, - copy_fn, - free_fn, + ©_fn.glib_name, + &free_fn.glib_name, &analysis.init_function_expression, &analysis.clear_function_expression, analysis.glib_get_type.as_ref().map(|(f, v)| { @@ -100,7 +100,15 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info) write!(w, "impl {} {{", analysis.name)?; for func_analysis in &analysis.functions { - function::generate(w, env, func_analysis, false, false, 1)?; + function::generate( + w, + env, + func_analysis, + Some(&analysis.specials), + false, + false, + 1, + )?; } writeln!(w, "}}")?; diff --git a/src/codegen/special_functions.rs b/src/codegen/special_functions.rs new file mode 100644 index 000000000..8aa0e2cc8 --- /dev/null +++ b/src/codegen/special_functions.rs @@ -0,0 +1,60 @@ +use std::io::{Result, Write}; + +use crate::{ + analysis::{self, functions::Visibility, special_functions::FunctionType}, + Env, +}; + +use super::general::version_condition; + +pub(super) fn generate( + w: &mut dyn Write, + env: &Env, + function: &analysis::functions::Info, + specials: &analysis::special_functions::Infos, +) -> Result { + if let Some(special) = specials.functions().get(&function.glib_name) { + match special.type_ { + FunctionType::StaticStringify => generate_static_to_str(w, env, function), + } + .map(|()| true) + } else { + Ok(false) + } +} + +pub(super) fn generate_static_to_str( + w: &mut dyn Write, + env: &Env, + function: &analysis::functions::Info, +) -> Result<()> { + writeln!(w)?; + version_condition(w, env, function.version, false, 1)?; + + let visibility = match function.visibility { + Visibility::Public => "pub ", + _ => "", + }; + + writeln!( + w, + "\ +\t{visibility}fn {rust_fn_name}<'a>(self) -> &'a str {{ +\t\tunsafe {{ +\t\t\tCStr::from_ptr( +\t\t\t\t{ns}::{glib_fn_name}(self.to_glib()) +\t\t\t\t\t.as_ref() +\t\t\t\t\t.expect(\"{glib_fn_name} returned NULL\"), +\t\t\t) +\t\t\t.to_str() +\t\t\t.expect(\"{glib_fn_name} returned an invalid string\") +\t\t}} +\t}}", + visibility = visibility, + rust_fn_name = function.name, + ns = env.main_sys_crate_name(), + glib_fn_name = function.glib_name, + )?; + + Ok(()) +} diff --git a/src/codegen/trait_impls.rs b/src/codegen/trait_impls.rs index 7eb81ba61..7a8a734fe 100644 --- a/src/codegen/trait_impls.rs +++ b/src/codegen/trait_impls.rs @@ -16,11 +16,11 @@ pub fn generate( specials: &Infos, trait_name: Option<&str>, ) -> Result<()> { - for (type_, name) in specials.iter() { - if let Some(info) = lookup(functions, name) { + for (type_, special_info) in specials.traits().iter() { + if let Some(info) = lookup(functions, &special_info.glib_name) { match *type_ { Type::Compare => { - if !specials.contains_key(&Type::Equal) { + if !specials.has_trait(Type::Equal) { generate_eq_compare(w, env, type_name, info, trait_name)?; } generate_ord(w, env, type_name, info, trait_name)?; @@ -28,7 +28,7 @@ pub fn generate( Type::Equal => { generate_eq(w, env, type_name, info, trait_name)?; } - Type::ToString => generate_display(w, env, type_name, info, trait_name)?, + Type::Display => generate_display(w, env, type_name, info, trait_name)?, Type::Hash => generate_hash(w, env, type_name, info, trait_name)?, _ => {} } @@ -40,7 +40,7 @@ pub fn generate( fn lookup<'a>(functions: &'a [Info], name: &str) -> Option<&'a Info> { functions .iter() - .find(|f| f.status.need_generate() && f.glib_name == name) + .find(|f| !f.status.ignored() && f.glib_name == name) } fn generate_call(func_name: &str, args: &[&str], trait_name: Option<&str>) -> String { diff --git a/src/env.rs b/src/env.rs index 20a69ee70..26d6be55b 100644 --- a/src/env.rs +++ b/src/env.rs @@ -53,10 +53,6 @@ impl Env { } pub fn main_sys_crate_name(&self) -> &str { - if &self.namespaces[MAIN_NAMESPACE].sys_crate_name != "gobject_ffi" { - "ffi" - } else { - "gobject_ffi" - } + &self.namespaces[MAIN_NAMESPACE].sys_crate_name } }