GeneratorEnv rework

Author: twistedfall

binding-generator/src/bin/settings-cleanup.rs

@@ -11,6 +11,7 @@ use opencv_binding_generator::{
 };
 
 struct FunctionFinder<'tu, 'f> {
+	pub module: &'tu str,
 	pub gen_env: GeneratorEnv<'tu>,
 	pub func_rename_unused: RefCell<&'f mut HashSet<&'static str>>,
 	pub func_exclude_unused: RefCell<&'f mut HashSet<&'static str>>,
@@ -38,7 +39,7 @@ impl<'tu, 'f> FunctionFinder<'tu, 'f> {
 
 impl<'tu> EntityWalkerVisitor<'tu> for FunctionFinder<'tu, '_> {
 	fn wants_file(&mut self, path: &Path) -> bool {
-		opencv_module_from_path(path).map_or(false, |m| m == self.gen_env.module())
+		opencv_module_from_path(path).map_or(false, |m| m == self.module)
 	}
 
 	fn visit_entity(&mut self, entity: Entity<'tu>) -> ControlFlow<()> {
@@ -110,8 +111,9 @@ fn main() {
 		for module in modules {
 			println!("  {module}");
 			gen.pre_process(&module, false, |root_entity| {
-				let gen_env = GeneratorEnv::new(root_entity, &module);
+				let gen_env = GeneratorEnv::global(&module, root_entity);
 				root_entity.walk_opencv_entities(FunctionFinder {
+					module: &module,
 					gen_env,
 					func_rename_unused: RefCell::new(&mut func_rename_unused),
 					func_exclude_unused: RefCell::new(&mut func_exclude_unused),

binding-generator/src/class.rs

@@ -350,18 +350,19 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 			out.push(func);
 			ControlFlow::Continue(())
 		});
-		let rust_module = match self {
-			Class::Clang { gen_env, .. } => gen_env.module(),
-			Class::Desc(desc) => desc.rust_module.as_ref(),
-		};
-		for inject_func_fact in settings::FUNC_INJECT.get(rust_module).into_iter().flatten() {
-			let inject_func: Func = inject_func_fact();
-			if let Some(cls) = inject_func.kind().as_class_method() {
-				if cls == self {
-					out.push(inject_func);
+		match self {
+			Class::Clang { gen_env, .. } => {
+				for inject_func_fact in &gen_env.settings.func_inject {
+					let inject_func: Func = inject_func_fact();
+					if let Some(cls) = inject_func.kind().as_class_method() {
+						if cls == self {
+							out.push(inject_func);
+						}
+					}
 				}
 			}
-		}
+			Class::Desc(_) => {}
+		};
 		out
 	}
 

binding-generator/src/func.rs

@@ -6,12 +6,11 @@ use std::ops::ControlFlow;
 use std::rc::Rc;
 
 use clang::{Availability, Entity, EntityKind, ExceptionSpecification};
-use once_cell::sync::Lazy;
-use regex::bytes::Regex;
-
 pub use desc::{FuncCppBody, FuncDesc, FuncRustBody, FuncRustExtern};
 pub use func_id::FuncId;
 pub use kind::{FuncKind, OperatorKind, ReturnKind};
+use once_cell::sync::Lazy;
+use regex::bytes::Regex;
 use slice_arg_finder::SliceArgFinder;
 
 use crate::comment::strip_doxygen_comment_markers;
@@ -391,13 +390,17 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 	}
 
 	pub fn safety(&self) -> Safety {
-		Safety::from_unsafe(
-			settings::FUNC_UNSAFE.contains(&self.func_id())
-				|| self.arguments().iter().any(|a| {
-					let type_ref = a.type_ref();
-					type_ref.kind().is_rust_by_ptr(type_ref.type_hint()) && !a.is_user_data()
-				}),
-		)
+		// todo move FUNC_UNSAFE to gen_env.settings, but can't do that now because setAllocator is a Desc function and it needs to be unsafe
+		let out = match self {
+			Func::Clang { .. } => Safety::from_is_unsafe(settings::FUNC_UNSAFE.contains(&self.func_id())),
+			Func::Desc(_) => Safety::from_is_unsafe(settings::FUNC_UNSAFE.contains(&self.func_id())),
+		};
+		out.or_is_unsafe(|| {
+			self.arguments().iter().any(|a| {
+				let type_ref = a.type_ref();
+				type_ref.kind().is_rust_by_ptr(type_ref.type_hint()) && !a.is_user_data()
+			})
+		})
 	}
 
 	pub fn is_default_constructor(&self) -> bool {
@@ -757,7 +760,7 @@ pub enum Safety {
 }
 
 impl Safety {
-	pub fn from_unsafe(is_unsafe: bool) -> Safety {
+	pub fn from_is_unsafe(is_unsafe: bool) -> Safety {
 		if is_unsafe {
 			Self::Unsafe
 		} else {
@@ -772,6 +775,14 @@ impl Safety {
 		}
 	}
 
+	/// Returns `Safe` only if both `self` and `other_is_unsafe` are `Safe`, otherwise returns `Unsafe`
+	pub fn or_is_unsafe(self, other_is_unsafe: impl FnOnce() -> bool) -> Safety {
+		match self {
+			Safety::Safe => Self::from_is_unsafe(other_is_unsafe()),
+			Safety::Unsafe => Self::Unsafe,
+		}
+	}
+
 	/// Returns `""` or `"unsafe "`, for usage for unsafe blocks within functions with `self` safety
 	pub fn rust_block_safety_qual(self) -> &'static str {
 		match self {

binding-generator/src/generator.rs

@@ -78,6 +78,7 @@ pub trait GeneratorVisitor<'tu>: Sized {
 /// all or is internal) and calls the corresponding method in [GeneratorVisitor] based on their type. This is the 2nd pass of the
 /// binding generation.
 struct OpenCvWalker<'tu, 'r, V> {
+	module: &'r str,
 	opencv_module_header_dir: &'r Path,
 	visitor: V,
 	gen_env: GeneratorEnv<'tu>,
@@ -159,7 +160,7 @@ impl<'tu, V: GeneratorVisitor<'tu>> EntityWalkerVisitor<'tu> for OpenCvWalker<'t
 		// method of extracting comments
 		let mut comment = String::with_capacity(2048);
 		let mut found_module_comment = false;
-		let module_path = self.opencv_module_header_dir.join(format!("{}.hpp", self.gen_env.module()));
+		let module_path = self.opencv_module_header_dir.join(format!("{}.hpp", self.module));
 		if let Ok(module_file) = File::open(module_path) {
 			let f = BufReader::new(module_file);
 			let mut defgroup_found = false;
@@ -188,26 +189,25 @@ impl<'tu, V: GeneratorVisitor<'tu>> EntityWalkerVisitor<'tu> for OpenCvWalker<'t
 		if found_module_comment {
 			self.visitor.visit_module_comment(comment);
 		}
-		for inject_func_fact in settings::FUNC_INJECT.get(self.gen_env.module()).into_iter().flatten() {
+		for inject_func_fact in &self.gen_env.settings.func_inject {
 			let inject_func: Func = inject_func_fact();
 			if !inject_func.kind().as_class_method().is_some() {
 				self.visitor.visit_func(inject_func);
 			}
 		}
-		if let Some(tweaks) = settings::GENERATOR_MODULE_TWEAKS.get(self.gen_env.module()) {
-			for generated in &tweaks.generate_types {
-				if let Ok(generated) = GeneratedType::try_from(generated()) {
-					self.visitor.visit_generated_type(generated);
-				}
+		for generated in &self.gen_env.settings.generator_module_tweaks.generate_types {
+			if let Ok(generated) = GeneratedType::try_from(generated()) {
+				self.visitor.visit_generated_type(generated);
 			}
 		}
 		self.visitor.goodbye();
 	}
 }
 
 impl<'tu, 'r, V: GeneratorVisitor<'tu>> OpenCvWalker<'tu, 'r, V> {
-	pub fn new(opencv_module_header_dir: &'r Path, visitor: V, gen_env: GeneratorEnv<'tu>) -> Self {
+	pub fn new(module: &'r str, opencv_module_header_dir: &'r Path, visitor: V, gen_env: GeneratorEnv<'tu>) -> Self {
 		Self {
+			module,
 			opencv_module_header_dir,
 			visitor,
 			gen_env,
@@ -468,8 +468,8 @@ impl Generator {
 	/// Runs the full binding generation process using the supplied `visitor`
 	pub fn generate(&self, module: &str, visitor: impl for<'tu> GeneratorVisitor<'tu>) {
 		self.pre_process(module, true, |root_entity| {
-			let gen_env = GeneratorEnv::new(root_entity, module);
-			let opencv_walker = OpenCvWalker::new(&self.opencv_module_header_dir, visitor, gen_env);
+			let gen_env = GeneratorEnv::global(module, root_entity);
+			let opencv_walker = OpenCvWalker::new(module, &self.opencv_module_header_dir, visitor, gen_env);
 			root_entity.walk_opencv_entities(opencv_walker);
 		});
 	}

binding-generator/src/generator_env.rs

@@ -11,6 +11,7 @@ use std::rc::Rc;
 use clang::{Entity, EntityKind, EntityVisitResult};
 
 use crate::class::ClassKind;
+use crate::settings::Settings;
 use crate::type_ref::CppNameStyle;
 use crate::{
 	is_opencv_path, opencv_module_from_path, settings, Class, Element, EntityWalkerExt, EntityWalkerVisitor, MemoizeMap,
@@ -104,6 +105,7 @@ struct ExportIdx {
 ///
 /// This is 1st pass of the analysis. It performs the collection of the necessary auxiliary data like which descendants a class has.
 struct GeneratorEnvPopulator<'tu, 'ge> {
+	module: &'tu str,
 	gen_env: &'ge mut GeneratorEnv<'tu>,
 }
 
@@ -133,7 +135,7 @@ impl<'tu> GeneratorEnvPopulator<'tu, '_> {
 
 impl<'tu> EntityWalkerVisitor<'tu> for GeneratorEnvPopulator<'tu, '_> {
 	fn wants_file(&mut self, path: &Path) -> bool {
-		is_opencv_path(path) || opencv_module_from_path(path).map_or(false, |m| m == self.gen_env.module())
+		is_opencv_path(path) || opencv_module_from_path(path).map_or(false, |m| m == self.module)
 	}
 
 	fn visit_entity(&mut self, entity: Entity<'tu>) -> ControlFlow<()> {
@@ -169,8 +171,6 @@ impl<'tu> EntityWalkerVisitor<'tu> for GeneratorEnvPopulator<'tu, '_> {
 /// This is partially pre-populated in an additional pass before the generation to provide some necessary data that's not available
 /// at the generation moment. E.g. list of descendants of a particular class.
 pub struct GeneratorEnv<'tu> {
-	/// The name of the module that's currently being generated
-	module: &'tu str,
 	export_map: HashMap<ExportIdx, ExportConfig>,
 	rename_map: HashMap<ExportIdx, RenameConfig>,
 	pub func_names: NamePool,
@@ -179,28 +179,40 @@ pub struct GeneratorEnv<'tu> {
 	/// Cache of the calculated [ClassKind]s
 	class_kind_cache: MemoizeMap<String, Option<ClassKind>>,
 	descendants: HashMap<String, HashSet<Entity<'tu>>>,
+	pub settings: Settings,
 }
 
 impl<'tu> GeneratorEnv<'tu> {
-	pub fn new(root_entity: Entity<'tu>, module: &'tu str) -> Self {
+	pub fn empty() -> Self {
+		Self {
+			export_map: HashMap::new(),
+			rename_map: HashMap::new(),
+			func_names: NamePool::with_capacity(0),
+			func_comments: HashMap::new(),
+			class_kind_cache: MemoizeMap::new(HashMap::new()),
+			descendants: HashMap::new(),
+			settings: Settings::empty(),
+		}
+	}
+
+	/// [GeneratorEnv] with the global settings for the regular working mode
+	pub fn global(module: &'tu str, root_entity: Entity<'tu>) -> Self {
 		let mut out = Self {
-			module,
 			export_map: HashMap::with_capacity(1024),
 			rename_map: HashMap::with_capacity(64),
 			func_names: NamePool::with_capacity(512),
 			func_comments: HashMap::with_capacity(2048),
 			class_kind_cache: MemoizeMap::new(HashMap::with_capacity(32)),
 			descendants: HashMap::with_capacity(16),
+			settings: Settings::for_module(module),
 		};
-		root_entity.walk_opencv_entities(GeneratorEnvPopulator { gen_env: &mut out });
+		root_entity.walk_opencv_entities(GeneratorEnvPopulator {
+			module,
+			gen_env: &mut out,
+		});
 		out
 	}
 
-	/// The name of the module that's currently being generated
-	pub fn module(&self) -> &str {
-		self.module
-	}
-
 	fn key(entity: Entity) -> ExportIdx {
 		let (loc, line_offset) = if entity.get_kind() == EntityKind::MacroExpansion {
 			// sometimes CV_EXPORT macros are located on a separate line so for those we compensate the offset
@@ -353,11 +365,15 @@ impl fmt::Debug for GeneratorEnv<'_> {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		f.debug_struct("GeneratorEnv")
 			.field("export_map", &format!("{} elements", self.export_map.len()))
+			.field("rename_map", &format!("{} elements", self.rename_map.len()))
+			.field("func_names", &format!("{} elements", self.func_names.len()))
 			.field("func_comments", &format!("{} elements", self.func_comments.len()))
 			.field(
 				"class_kind_cache",
 				&format!("{} elements", self.class_kind_cache.borrow().len()),
 			)
+			.field("descendants", &format!("{} elements", self.descendants.len()))
+			.field("settings", &self.settings)
 			.finish()
 	}
 }

binding-generator/src/name_pool.rs

@@ -14,6 +14,10 @@ impl NamePool {
 		}
 	}
 
+	pub fn len(&self) -> usize {
+		self.names.len()
+	}
+
 	pub fn make_unique_name(&mut self, name: &mut Cow<str>) -> MakeUniqueNameResult {
 		let mut out = MakeUniqueNameResult::Unchanged;
 		while self.names.contains(name.as_ref()) {

binding-generator/src/settings.rs

@@ -2,25 +2,24 @@
 
 use std::collections::{BTreeSet, HashMap, HashSet};
 
-use once_cell::sync::Lazy;
-
 pub use argument_names::{ARGUMENT_NAMES_MULTIPLE_SLICE, ARGUMENT_NAMES_NOT_SLICE, ARGUMENT_NAMES_USERDATA};
 pub use argument_override::{ARGUMENT_OVERRIDE, ARG_OVERRIDE_SELF, RETURN_OVERRIDE};
 pub use element_exclude_kind::ELEMENT_EXCLUDE_KIND;
 pub use element_export_tweak::ELEMENT_EXPORT_TWEAK;
 pub use force_infallible::FORCE_INFALLIBLE;
 pub use func_cfg_attr::FUNC_CFG_ATTR;
 pub use func_exclude::FUNC_EXCLUDE;
-pub use func_inject::{FuncFactory, FUNC_INJECT};
+pub use func_inject::{func_inject_factory, FuncFactory};
 pub use func_rename::FUNC_RENAME;
 pub use func_replace::{FuncInheritFactory, FUNC_REPLACE};
 pub use func_specialize::{TypeRefFactory, FUNC_SPECIALIZE};
 pub use func_unsafe::FUNC_UNSAFE;
-pub use generator_module_tweaks::{ModuleTweak, GENERATOR_MODULE_TWEAKS};
+pub use generator_module_tweaks::{generator_module_tweaks_factory, ModuleTweak};
 pub use implemented::{
 	IMPLEMENTED_CONST_GENERICS, IMPLEMENTED_FUNCTION_LIKE_MACROS, IMPLEMENTED_GENERICS, IMPLEMENTED_MANUAL_DEBUG,
 	IMPLEMENTED_SYSTEM_CLASSES,
 };
+use once_cell::sync::Lazy;
 
 mod argument_names;
 mod argument_override;
@@ -37,6 +36,29 @@ mod func_unsafe;
 mod generator_module_tweaks;
 mod implemented;
 
+/// Injectable global and module level overrides, todo: migrate the global statics to this over time
+#[derive(Debug)]
+pub struct Settings {
+	pub func_inject: Vec<FuncFactory>,
+	pub generator_module_tweaks: ModuleTweak,
+}
+
+impl Settings {
+	pub fn empty() -> Self {
+		Self {
+			func_inject: vec![],
+			generator_module_tweaks: ModuleTweak::empty(),
+		}
+	}
+
+	pub fn for_module(module: &str) -> Self {
+		Self {
+			func_inject: func_inject_factory(module),
+			generator_module_tweaks: generator_module_tweaks_factory(module),
+		}
+	}
+}
+
 // fixme, generalize, make it use constant::ValueKind
 pub static CONST_TYPE_USIZE: Lazy<HashSet<&str>> = Lazy::new(|| HashSet::from(["Mat_AUTO_STEP"]));
 

binding-generator/src/settings/func_inject.rs

@@ -1,7 +1,3 @@
-use std::collections::HashMap;
-
-use once_cell::sync::Lazy;
-
 use crate::class::ClassDesc;
 use crate::field::{Field, FieldDesc};
 use crate::func::{FuncCppBody, FuncDesc, FuncKind, FuncRustBody, ReturnKind};
@@ -12,11 +8,9 @@ use crate::Func;
 
 pub type FuncFactory = fn() -> Func<'static, 'static>;
 
-/// (module name, FuncFactory)
-pub static FUNC_INJECT: Lazy<HashMap<&str, Vec<FuncFactory>>> = Lazy::new(|| {
-	HashMap::from([(
-		"core",
-		vec![
+pub fn func_inject_factory(module: &str) -> Vec<FuncFactory> {
+	match module {
+		"core" => vec![
 			(|| {
 				Func::new_desc(FuncDesc::new(
 					FuncKind::InstanceMethod(ClassDesc::cv_matconstiterator()),
@@ -82,5 +76,6 @@ pub static FUNC_INJECT: Lazy<HashMap<&str, Vec<FuncFactory>>> = Lazy::new(|| {
 				))
 			},
 		],
-	)])
-});
+		_ => vec![],
+	}
+}