Cleanup

Author: twistedfall

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

@@ -1,10 +1,11 @@
 use std::env;
 use std::fs::File;
 use std::io::BufReader;
+use std::ops::ControlFlow;
 use std::path::{Path, PathBuf};
 
 use opencv_binding_generator::writer::RustNativeBindingWriter;
-use opencv_binding_generator::{line_reader, Generator, LineReaderAction};
+use opencv_binding_generator::{line_reader, Generator};
 
 fn get_version_header(header_dir: &Path) -> Option<PathBuf> {
 	let out = header_dir.join("opencv2/core/version.hpp");
@@ -44,10 +45,10 @@ fn get_version_from_headers(header_dir: &Path) -> Option<String> {
 				}
 			}
 			if major.is_some() && minor.is_some() && revision.is_some() {
-				return LineReaderAction::Break;
+				return ControlFlow::Break(());
 			}
 		}
-		LineReaderAction::Continue
+		ControlFlow::Continue(())
 	});
 	if let (Some(major), Some(minor), Some(revision)) = (major, minor, revision) {
 		Some(format!("{major}.{minor}.{revision}"))

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

@@ -5,7 +5,6 @@ use std::path::{Path, PathBuf};
 use std::{env, fmt};
 
 use clang::{Entity, EntityKind};
-
 use opencv_binding_generator::{
 	opencv_module_from_path, settings, Class, EntityExt, EntityWalkerExt, EntityWalkerVisitor, Func, FuncId, Generator,
 	GeneratorEnv,

binding-generator/src/class.rs

@@ -6,7 +6,6 @@ use std::rc::Rc;
 use std::{fmt, iter};
 
 use clang::{Accessibility, Entity, EntityKind};
-
 pub use desc::ClassDesc;
 
 use crate::comment::strip_doxygen_comment_markers;
@@ -448,7 +447,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 									def_loc: fld.file_line_name().location,
 									rust_generic_decls: Rc::new([]),
 									arguments: Rc::new([]),
-									return_type_ref: fld_type_ref.with_inherent_constness(Constness::Const),
+									return_type_ref: fld_type_ref.as_ref().clone().with_inherent_constness(Constness::Const),
 									cpp_body: FuncCppBody::ManualCall("{{name}}".into()),
 									rust_body: FuncRustBody::Auto,
 									rust_extern_definition: FuncRustExtern::Auto,
@@ -470,7 +469,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 									def_loc: fld.file_line_name().location,
 									rust_generic_decls: Rc::new([]),
 									arguments: Rc::new([]),
-									return_type_ref: fld_type_ref.with_inherent_constness(Constness::Mut),
+									return_type_ref: fld_type_ref.as_ref().clone().with_inherent_constness(Constness::Mut),
 									cpp_body: FuncCppBody::ManualCall("{{name}}".into()),
 									rust_body: FuncRustBody::Auto,
 									rust_extern_definition: FuncRustExtern::Auto,
@@ -521,7 +520,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 								rust_generic_decls: Rc::new([]),
 								arguments: Rc::new([Field::new_desc(FieldDesc {
 									cpp_fullname: "val".into(),
-									type_ref: fld_type_ref.with_inherent_constness(Constness::Const),
+									type_ref: fld_type_ref.as_ref().clone().with_inherent_constness(Constness::Const),
 									default_value: fld.default_value().map(|v| v.into()),
 								})]),
 								return_kind: ReturnKind::InfallibleNaked,

binding-generator/src/constant.rs

@@ -42,7 +42,7 @@ pub fn render_constant_rust(tokens: &[Token]) -> Option<Value> {
 			}
 			TokenKind::Literal => {
 				let spelling = t.get_spelling();
-				if spelling.contains(|c| c == '"' || c == '\'') {
+				if spelling.contains(['"', '\'']) {
 					out.kind = ValueKind::String;
 				} else if spelling.contains('.') {
 					out.kind = ValueKind::Float;

binding-generator/src/enumeration.rs

@@ -36,7 +36,7 @@ impl<'tu> Enum<'tu> {
 		self.entity.is_anonymous() || /* clang-6 quirk */ self.cpp_name(CppNameStyle::Declaration).starts_with("(anonymous enum")
 	}
 
-	pub fn as_typedefed(&self) -> Option<Entity> {
+	pub fn as_typedefed(&self) -> Option<Entity<'tu>> {
 		if matches!(self.entity.get_kind(), EntityKind::TypedefDecl | EntityKind::TypeAliasDecl) {
 			let mut child = None;
 			self.entity.walk_children_while(|c| {
@@ -49,7 +49,7 @@ impl<'tu> Enum<'tu> {
 		}
 	}
 
-	pub fn consts(&self) -> Vec<Const> {
+	pub fn consts(&self) -> Vec<Const<'tu>> {
 		let mut out = vec![];
 		self.as_typedefed().unwrap_or(self.entity).visit_children(|const_decl, _| {
 			if const_decl.get_kind() == EntityKind::EnumConstantDecl {

binding-generator/src/field.rs

@@ -43,14 +43,20 @@ impl<'tu, 'ge> Field<'tu, 'ge> {
 		Self::Desc(Rc::new(desc))
 	}
 
-	pub(crate) fn to_desc(&self) -> Rc<FieldDesc<'tu, 'ge>> {
+	pub(crate) fn to_desc(&self, new_typeref: Option<TypeRef<'tu, 'ge>>) -> Rc<FieldDesc<'tu, 'ge>> {
 		match self {
-			Self::Clang { type_ref_type_hint, .. } => Rc::new(FieldDesc {
+			Self::Clang { .. } => Rc::new(FieldDesc {
 				cpp_fullname: self.cpp_name(CppNameStyle::Reference).into(),
-				type_ref: self.type_ref().into_owned().with_type_hint(type_ref_type_hint.clone()), // todo: add an option to avoid inheriting type_ref
+				type_ref: new_typeref.unwrap_or_else(|| self.type_ref().into_owned()),
 				default_value: self.default_value().map(Rc::from),
 			}),
-			Self::Desc(desc) => Rc::clone(desc),
+			Self::Desc(desc) => {
+				let mut out = Rc::clone(desc);
+				if let Some(new_typeref) = new_typeref {
+					Rc::make_mut(&mut out).type_ref = new_typeref;
+				}
+				out
+			}
 		}
 	}
 
@@ -88,9 +94,7 @@ impl<'tu, 'ge> Field<'tu, 'ge> {
 				..
 			} => {
 				let type_ref_type_hint = type_ref_type_hint.clone().something_or_else(|| {
-					let default_value_string = self
-						.default_value()
-						.map_or(false, |def| def.contains(|c| c == '"' || c == '\''));
+					let default_value_string = self.default_value().map_or(false, |def| def.contains(['"', '\'']));
 					if default_value_string {
 						TypeRefTypeHint::CharAsRustChar
 					} else {
@@ -108,10 +112,16 @@ impl<'tu, 'ge> Field<'tu, 'ge> {
 		}
 	}
 
-	pub fn with_type_ref(&self, type_ref: TypeRef<'tu, 'ge>) -> Self {
-		let mut desc = self.to_desc();
-		Rc::make_mut(&mut desc).type_ref = type_ref;
-		Self::Desc(desc)
+	pub fn with_type_ref(mut self, type_ref: TypeRef<'tu, 'ge>) -> Self {
+		self.set_type_ref(type_ref);
+		self
+	}
+
+	pub fn set_type_ref(&mut self, type_ref: TypeRef<'tu, 'ge>) {
+		match self {
+			Self::Clang { .. } => *self = Self::Desc(self.to_desc(Some(type_ref))),
+			Self::Desc(desc) => Rc::make_mut(desc).type_ref = type_ref,
+		}
 	}
 
 	pub fn constness(&self) -> Constness {

binding-generator/src/generator.rs

@@ -15,7 +15,7 @@ use crate::typedef::NewTypedefResult;
 use crate::writer::rust_native::element::RustElement;
 use crate::{
 	get_definition_text, line_reader, settings, AbstractRefWrapper, Class, ClassKindOverride, Const, Element, EntityExt,
-	EntityWalkerExt, EntityWalkerVisitor, Enum, Func, GeneratorEnv, LineReaderAction, SmartPtr, Tuple, Typedef, Vector,
+	EntityWalkerExt, EntityWalkerVisitor, Enum, Func, GeneratorEnv, SmartPtr, Tuple, Typedef, Vector,
 };
 
 #[derive(Debug)]
@@ -41,7 +41,7 @@ impl<'tu, 'ge> TryFrom<TypeRef<'tu, 'ge>> for GeneratedType<'tu, 'ge> {
 
 /// Visitor of the different supported OpenCV entities, used in conjunction with [Generator]
 #[allow(unused)]
-pub trait GeneratorVisitor {
+pub trait GeneratorVisitor<'tu>: Sized {
 	/// Check whether the visitor is interested in entities from the specified file
 	fn wants_file(&mut self, path: &Path) -> bool {
 		true
@@ -51,36 +51,39 @@ pub trait GeneratorVisitor {
 	fn visit_module_comment(&mut self, comment: String) {}
 
 	/// Top-level constant
-	fn visit_const(&mut self, cnst: Const) {}
+	fn visit_const(&mut self, cnst: Const<'tu>) {}
 
 	/// Top-level enum
-	fn visit_enum(&mut self, enm: Enum) {}
+	fn visit_enum(&mut self, enm: Enum<'tu>) {}
 
 	/// Top-level function
-	fn visit_func(&mut self, func: Func) {}
+	fn visit_func(&mut self, func: Func<'tu, '_>) {}
 
 	/// Top-level type alias
-	fn visit_typedef(&mut self, typedef: Typedef) {}
+	fn visit_typedef(&mut self, typedef: Typedef<'tu, '_>) {}
 
 	/// Top-level class or an internal class of another class
-	fn visit_class(&mut self, class: Class) {}
+	fn visit_class(&mut self, class: Class<'tu, '_>) {}
 
 	/// Dependent generated type like `std::vector<Mat>` or `std::tuple<1, 2, 3>`
-	fn visit_generated_type(&mut self, typ: GeneratedType) {}
+	fn visit_generated_type(&mut self, typ: GeneratedType<'tu, '_>) {}
+
+	/// Called at the end of the visitation
+	fn goodbye(self) {}
 }
 
 /// Bridge between [EntityWalkerVisitor] and [GeneratorVisitor]
 ///
 /// It takes [Entity]s supplied by the entity walker, extracts their export data (whether the entity should appear in bindings at
 /// 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: GeneratorVisitor> {
+struct OpenCvWalker<'tu, 'r, V> {
 	opencv_module_header_dir: &'r Path,
 	visitor: V,
 	gen_env: GeneratorEnv<'tu>,
 }
 
-impl<'tu, V: GeneratorVisitor> EntityWalkerVisitor<'tu> for OpenCvWalker<'tu, '_, V> {
+impl<'tu, V: GeneratorVisitor<'tu>> EntityWalkerVisitor<'tu> for OpenCvWalker<'tu, '_, V> {
 	fn wants_file(&mut self, path: &Path) -> bool {
 		self.visitor.wants_file(path) || path.ends_with("ocvrs_common.hpp")
 	}
@@ -148,9 +151,61 @@ impl<'tu, V: GeneratorVisitor> EntityWalkerVisitor<'tu> for OpenCvWalker<'tu, '_
 		}
 		ControlFlow::Continue(())
 	}
+
+	fn goodbye(mut self) {
+		// Some module level comments like "bioinspired" are not attached to anything and libclang
+		// doesn't seem to offer a way to extract them, do it the hard way then.
+		// That's actually the case for all modules starting with OpenCV 4.8.0 so this is now a single
+		// 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()));
+		if let Ok(module_file) = File::open(module_path) {
+			let f = BufReader::new(module_file);
+			let mut defgroup_found = false;
+			line_reader(f, |line| {
+				if !found_module_comment && line.trim_start().starts_with("/**") {
+					found_module_comment = true;
+					defgroup_found = false;
+				}
+				if found_module_comment {
+					if comment.contains("@defgroup") {
+						defgroup_found = true;
+					}
+					comment.push_str(line);
+					if line.trim_end().ends_with("*/") {
+						if defgroup_found {
+							return ControlFlow::Break(());
+						} else {
+							comment.clear();
+							found_module_comment = false;
+						}
+					}
+				}
+				ControlFlow::Continue(())
+			});
+		}
+		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() {
+			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);
+				}
+			}
+		}
+		self.visitor.goodbye();
+	}
 }
 
-impl<'tu, 'r, V: GeneratorVisitor> OpenCvWalker<'tu, 'r, V> {
+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 {
 		Self {
 			opencv_module_header_dir,
@@ -159,7 +214,7 @@ impl<'tu, 'r, V: GeneratorVisitor> OpenCvWalker<'tu, 'r, V> {
 		}
 	}
 
-	fn process_const(visitor: &mut V, const_decl: Entity) {
+	fn process_const(visitor: &mut V, const_decl: Entity<'tu>) {
 		let cnst = Const::new(const_decl);
 		if cnst.exclude_kind().is_included() {
 			visitor.visit_const(cnst);
@@ -202,7 +257,7 @@ impl<'tu, 'r, V: GeneratorVisitor> OpenCvWalker<'tu, 'r, V> {
 		}
 	}
 
-	fn process_enum(visitor: &mut V, enum_decl: Entity) {
+	fn process_enum(visitor: &mut V, enum_decl: Entity<'tu>) {
 		let enm = Enum::new(enum_decl);
 		if enm.exclude_kind().is_included() {
 			for cnst in enm.consts() {
@@ -294,57 +349,6 @@ impl<'tu, 'r, V: GeneratorVisitor> OpenCvWalker<'tu, 'r, V> {
 	}
 }
 
-impl<V: GeneratorVisitor> Drop for OpenCvWalker<'_, '_, V> {
-	fn drop(&mut self) {
-		// Some module level comments like "bioinspired" are not attached to anything and libclang
-		// doesn't seem to offer a way to extract them, do it the hard way then.
-		// That's actually the case for all modules starting with OpenCV 4.8.0 so this is now a single
-		// method of extracting comments
-		let mut comment = String::with_capacity(2048);
-		let module_path = self.opencv_module_header_dir.join(format!("{}.hpp", self.gen_env.module()));
-		let f = BufReader::new(File::open(module_path).expect("Can't open main module file"));
-		let mut found_module_comment = false;
-		let mut defgroup_found = false;
-		line_reader(f, |line| {
-			if !found_module_comment && line.trim_start().starts_with("/**") {
-				found_module_comment = true;
-				defgroup_found = false;
-			}
-			if found_module_comment {
-				if comment.contains("@defgroup") {
-					defgroup_found = true;
-				}
-				comment.push_str(line);
-				if line.trim_end().ends_with("*/") {
-					if defgroup_found {
-						return LineReaderAction::Break;
-					} else {
-						comment.clear();
-						found_module_comment = false;
-					}
-				}
-			}
-			LineReaderAction::Continue
-		});
-		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() {
-			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);
-				}
-			}
-		}
-	}
-}
-
 /// Main workhorse for generating OpenCV bindings for a specific module
 ///
 /// Full binding generation for a module is happening in the following major phases:
@@ -436,9 +440,9 @@ impl Generator {
 		// need to have c++14 here because VS headers contain features that require it
 		args.push("-std=c++14".into());
 		// allow us to use some custom clang args
-		if let Some(clang_arg_str) = env::var_os("OPENCV_CLANG_ARGS") {
-			let clang_arg = clang_arg_str.to_str().expect("Try to get OPENCV_CLANG_ARGS failed.");
-			Shlex::new(clang_arg).into_iter().for_each(|i| args.push(i.into()))
+		let clang_arg = env::var_os("OPENCV_CLANG_ARGS");
+		if let Some(clang_arg) = clang_arg.as_ref().and_then(|s| s.to_str()) {
+			args.extend(Shlex::new(clang_arg).map(Cow::Owned));
 		}
 		args
 	}
@@ -462,7 +466,7 @@ impl Generator {
 	}
 
 	/// Runs the full binding generation process using the supplied `visitor`
-	pub fn generate(&self, module: &str, visitor: impl GeneratorVisitor) {
+	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);