Cleanup

Author: twistedfall

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

@@ -46,14 +46,14 @@ impl<'tu> EntityWalkerVisitor<'tu> for &mut FunctionFinder<'tu> {
 					c.methods(|_| true).into_iter().for_each(|f| self.update_used_func(&f));
 					c.field_methods(&c.fields(|_| true), None)
 						.for_each(|f| self.update_used_func(&f));
-					entity.walk_methods_while(|child| {
+					let _ = entity.walk_methods_while(|child| {
 						let func = Func::new(child, &self.gen_env);
 						if func.is_generic() {
 							self.update_used_func(&func);
 						}
 						ControlFlow::Continue(())
 					});
-					entity.walk_classes_while(|child| self.visit_entity(child));
+					let _ = entity.walk_classes_while(|child| self.visit_entity(child));
 				}
 			}
 			EntityKind::FunctionDecl => {

binding-generator/src/class.rs

@@ -149,7 +149,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 		}
 	}
 
-	/// True if class has virtual methods
+	/// True if a class has virtual methods
 	pub fn is_polymorphic(&self) -> bool {
 		match self {
 			Self::Clang { entity, .. } => entity
@@ -159,7 +159,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 		}
 	}
 
-	/// Special case of an empty class with only an anonymous enum inside (e.g. DrawLinesMatchesFlags)
+	/// Special case of an empty class with only an anonymous enum inside (e.g., DrawLinesMatchesFlags)
 	pub fn as_enum(&self) -> Option<Enum<'tu>> {
 		match self {
 			&Self::Clang { entity, .. } => {
@@ -241,7 +241,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 			&Self::Clang { entity, gen_env, .. } => {
 				let mut out = vec![];
 				let entity = entity.get_template().unwrap_or(entity);
-				entity.walk_bases_while(|child| {
+				let _ = entity.walk_bases_while(|child| {
 					out.push(Self::new(Self::definition_entity(child), gen_env));
 					ControlFlow::Continue(())
 				});
@@ -333,7 +333,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 		match self {
 			Class::Clang { entity, gen_env, .. } => {
 				let mut out = Vec::with_capacity(32);
-				entity.walk_methods_while(|func_entity| {
+				let _ = entity.walk_methods_while(|func_entity| {
 					let func = Func::new(func_entity, gen_env);
 					let func: Func = if let Some(func_fact) = gen_env.settings.func_replace.get(&mut func.matcher()) {
 						func_fact(&func)
@@ -384,7 +384,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 
 	pub fn fields(&self, filter: impl Fn(&Field) -> bool) -> Vec<Field<'tu, 'ge>> {
 		let mut out = Vec::with_capacity(32);
-		self.for_each_field(|f| {
+		let _ = self.for_each_field(|f| {
 			if filter(&f) {
 				out.push(f);
 			}
@@ -403,7 +403,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 
 	pub fn consts(&self) -> Vec<Const<'tu>> {
 		let mut out = Vec::with_capacity(8);
-		self.for_each_const(|c| {
+		let _ = self.for_each_const(|c| {
 			out.push(c);
 			ControlFlow::Continue(())
 		});

binding-generator/src/enumeration.rs

@@ -39,7 +39,7 @@ impl<'tu> Enum<'tu> {
 	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| {
+			let _ = self.entity.walk_children_while(|c| {
 				child = Some(c);
 				ControlFlow::Break(())
 			});

binding-generator/src/func.rs

@@ -503,7 +503,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 		match self.kind().as_ref() {
 			FuncKind::GenericFunction | FuncKind::GenericInstanceMethod(..) => {
 				let mut out = Vec::with_capacity(8);
-				entity.walk_children_while(|child| {
+				let _ = entity.walk_children_while(|child| {
 					if child.get_kind() == EntityKind::ParmDecl {
 						out.push(child);
 					}

binding-generator/src/generator.rs

@@ -167,10 +167,9 @@ impl<'tu, V: GeneratorVisitor<'tu>> EntityWalkerVisitor<'tu> for OpenCvWalker<'t
 		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.module));
-		if let Ok(module_file) = File::open(module_path) {
-			let f = BufReader::new(module_file);
+		if let Ok(module_file) = File::open(module_path).map(BufReader::new) {
 			let mut defgroup_found = false;
-			line_reader(f, |line| {
+			line_reader(module_file, |line| {
 				if !found_module_comment && line.trim_start().starts_with("/**") {
 					found_module_comment = true;
 					defgroup_found = false;
@@ -235,11 +234,11 @@ impl<'tu, 'r, V: GeneratorVisitor<'tu>> OpenCvWalker<'tu, 'r, V> {
 				cls.generated_types().into_iter().for_each(|dep| {
 					visitor.visit_generated_type(dep);
 				});
-				class_decl.walk_enums_while(|enm| {
+				let _ = class_decl.walk_enums_while(|enm| {
 					Self::process_enum(visitor, enm);
 					ControlFlow::Continue(())
 				});
-				class_decl.walk_classes_while(|sub_cls| {
+				let _ = class_decl.walk_classes_while(|sub_cls| {
 					if !gen_env.get_export_config(sub_cls).is_some() {
 						gen_env.make_export_config(sub_cls).class_kind_override = if Class::new(sub_cls, gen_env).can_be_simple() {
 							ClassKindOverride::Simple
@@ -250,7 +249,7 @@ impl<'tu, 'r, V: GeneratorVisitor<'tu>> OpenCvWalker<'tu, 'r, V> {
 					Self::process_class(visitor, gen_env, sub_cls);
 					ControlFlow::Continue(())
 				});
-				class_decl.walk_typedefs_while(|tdef| {
+				let _ = class_decl.walk_typedefs_while(|tdef| {
 					Self::process_typedef(visitor, gen_env, tdef);
 					ControlFlow::Continue(())
 				});
@@ -368,7 +367,7 @@ impl Drop for Generator {
 				.iter()
 				.any(|bad_version| clang::get_version().contains(bad_version)))
 		{
-			// `clang` has an issue on Windows when running with `runtime` feature and clang-19+:
+			// `clang` has an issue on Windows when running with the `runtime` feature and clang-19+:
 			// https://github.com/KyleMayes/clang-rs/issues/63
 			// So we avoid dropping clang in that case as a workaround.
 			// `clang::get_version()` is string like "Apple clang version 15.0.0 (clang-1500.1.0.2.5)"

binding-generator/src/lib.rs

@@ -80,11 +80,11 @@ pub mod writer;
 fn get_definition_text(entity: Entity) -> String {
 	if let Some(range) = entity.get_range() {
 		let loc = range.get_start().get_spelling_location();
-		let mut source = File::open(loc.file.expect("Can't get file").get_path()).expect("Can't open source file");
 		let start = loc.offset;
 		let end = range.get_end().get_spelling_location().offset;
 		let len = usize::try_from(end - start).expect("Definition span is too large");
 		let mut def_bytes = vec![0; len];
+		let mut source = File::open(loc.file.expect("Can't get file").get_path()).expect("Can't open source file");
 		source.seek(SeekFrom::Start(u64::from(start))).expect("Cannot seek");
 		source.read_exact(&mut def_bytes).expect("Can't read definition");
 		String::from_utf8(def_bytes).expect("Can't parse definition")

binding-generator/src/type_ref.rs

@@ -113,14 +113,14 @@ impl<'tu, 'ge> TypeRef<'tu, 'ge> {
 		} else if let Some(primitive_typeref) = TypeRefDesc::try_primitive(cpp_refname) {
 			primitive_typeref
 		} else {
-			let simplicity = (settings::DATA_TYPES.contains(cpp_refname) || settings::DATA_TYPES_5_0.contains(cpp_refname))
-				.then_some(ClassKindOverride::Simple)
-				.unwrap_or_else(|| {
-					settings::ELEMENT_EXPORT_TWEAK
-						.get(cpp_refname)
-						.and_then(|export_tweak| export_tweak(ExportConfig::default()))
-						.map_or(ClassKindOverride::Boxed, |e| e.class_kind_override)
-				});
+			let simplicity = if settings::DATA_TYPES.contains(cpp_refname) || settings::DATA_TYPES_5_0.contains(cpp_refname) {
+				ClassKindOverride::Simple
+			} else {
+				settings::ELEMENT_EXPORT_TWEAK
+					.get(cpp_refname)
+					.and_then(|export_tweak| export_tweak(ExportConfig::default()))
+					.map_or(ClassKindOverride::Boxed, |e| e.class_kind_override)
+			};
 			let cls = if simplicity.is_boxed() {
 				ClassDesc::boxed(cpp_refname, rust_module)
 			} else {

binding-generator/src/type_ref/kind.rs

@@ -84,7 +84,7 @@ impl<'tu, 'ge> TypeRefKind<'tu, 'ge> {
 		}
 	}
 
-	/// TypeRefKind with all of the typedef's traversed
+	/// TypeRefKind with all the typedef's traversed
 	#[inline]
 	pub fn canonical(&self) -> Cow<Self> {
 		match self {
@@ -395,7 +395,7 @@ impl<'tu, 'ge> TypeRefKind<'tu, 'ge> {
 		}
 	}
 
-	/// True for types that get passed in Rust by pointer as opposed to a reference or an owned value
+	/// True for types that get passed in Rust by the pointer as opposed to a reference or an owned value
 	pub fn is_rust_by_ptr(&self, type_hint: &TypeRefTypeHint) -> bool {
 		self.as_pointer().is_some_and(|inner| {
 			let inner_kind = inner.kind();
@@ -409,7 +409,7 @@ impl<'tu, 'ge> TypeRefKind<'tu, 'ge> {
 		})
 	}
 
-	/// True for types that can be returned as direct reference to the underlying data that's allocated on C++ side
+	/// True for types that can be returned as direct reference to the underlying data that's allocated on the C++ side
 	pub fn can_return_as_direct_reference(&self) -> bool {
 		match self.canonical().as_ref() {
 			TypeRefKind::Array(elem, _) => elem.kind().is_copy(elem.type_hint()),
@@ -446,7 +446,7 @@ impl<'tu, 'ge> TypeRefKind<'tu, 'ge> {
 
 	/// True for types that can be returned via C++ `return`, otherwise they are returned through an argument
 	///
-	/// Some types especially larger `struct`s are not safe to just `return` over the FFI boundary because compilers don't always
+	/// Some types, especially larger `struct`s are not safe to just `return` over the FFI boundary because compilers don't always
 	/// agree on how exactly those should be returned. So only designated simpler and shorter types are returned this way. For
 	/// all other cases the return is passed through an additional argument.
 	pub fn return_as_naked(&self, type_hint: &TypeRefTypeHint) -> bool {
@@ -456,35 +456,13 @@ impl<'tu, 'ge> TypeRefKind<'tu, 'ge> {
 			kind => kind.extern_pass_kind().is_by_void_ptr() || kind.as_string(type_hint).is_some(),
 		}
 	}
-
-	/// True if it's possible to borrow from this type in Rust
-	///
-	/// Used mainly to decide whether the return type of function should have explicit or elided lifetime.
-	pub fn rust_can_borrow(&self, type_hint: &TypeRefTypeHint) -> bool {
-		match self {
-			TypeRefKind::Array(elem, _) => elem.kind().rust_can_borrow(type_hint),
-			TypeRefKind::StdVector(vec) => vec.element_type().kind().rust_can_borrow(type_hint),
-			TypeRefKind::StdTuple(tup) => tup.elements().iter().any(|e| e.kind().rust_can_borrow(type_hint)),
-			TypeRefKind::RValueReference(inner) => inner.kind().rust_can_borrow(type_hint),
-			TypeRefKind::SmartPtr(ptr) => ptr.pointee().kind().rust_can_borrow(type_hint),
-			TypeRefKind::Typedef(tdef) => tdef.underlying_type_ref().kind().rust_can_borrow(type_hint),
-			TypeRefKind::Pointer(_) if self.is_rust_by_ptr(type_hint) => false,
-			TypeRefKind::Pointer(_) | TypeRefKind::Reference(_) => true,
-			TypeRefKind::Primitive(_, _)
-			| TypeRefKind::Class(_)
-			| TypeRefKind::Enum(_)
-			| TypeRefKind::Function(_)
-			| TypeRefKind::Generic(_)
-			| TypeRefKind::Ignored => false,
-		}
-	}
 }
 
 #[derive(Clone, Copy, Debug)]
 pub enum ExternPassKind {
 	AsIs,
 	ByPtr,
-	/// Value of the type needs to be passed by pointer to a heap-allocated object to and from the C++ side
+	/// Value of the type needs to be passed by the pointer to a heap-allocated object to and from the C++ side
 	ByVoidPtr,
 }
 

binding-generator/src/typedef.rs

@@ -39,7 +39,7 @@ impl<'tu, 'ge> Typedef<'tu, 'ge> {
 	/// ```
 	pub fn try_new(entity: Entity<'tu>, gen_env: &'ge GeneratorEnv<'tu>) -> NewTypedefResult<'tu, 'ge> {
 		let mut out = NewTypedefResult::Typedef(Self::Clang { entity, gen_env });
-		entity.walk_children_while(|child| {
+		let _ = entity.walk_children_while(|child| {
 			let child_unnamed_or_same_name = child
 				.get_name()
 				.map_or(true, |child_name| Some(child_name) == entity.get_name());