Cleanup

Author: twistedfall

.github/workflows/opencv-rust.yml

@@ -67,7 +67,7 @@ jobs:
           - windows-2022
           - macos-14
         vcpkg-version:
-          - 2024.03.25
+          - 2024.04.26
     runs-on: ${{ matrix.os-image }}
     env:
       VCPKG_VERSION: ${{ matrix.vcpkg-version }}

binding-generator/src/class.rs

@@ -168,7 +168,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 					let children = entity.get_children();
 					if let [single] = children.as_slice() {
 						if matches!(single.get_kind(), EntityKind::EnumDecl) {
-							Some(Enum::new_ext(*single, self.cpp_name(CppNameStyle::Declaration).into_owned()))
+							Some(Enum::new_ext(*single, self.cpp_name(CppNameStyle::Declaration).as_ref()))
 						} else {
 							None
 						}
@@ -416,16 +416,16 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 				out.extend(fields.flat_map(|fld| {
 					iter::from_fn({
 						let doc_comment = Rc::from(fld.doc_comment());
-						let mut fld_type_ref = fld.type_ref().into_owned();
+						let mut fld_type_ref = fld.type_ref();
 						let fld_type_kind = fld_type_ref.kind();
 						if fld_type_kind
 							.as_pointer()
 							.map_or(false, |inner| inner.kind().as_primitive().is_some())
 							&& !fld_type_kind.is_char_ptr_string(fld_type_ref.type_hint())
 						{
-							fld_type_ref.set_type_hint(TypeRefTypeHint::PrimitivePtrAsRaw);
+							fld_type_ref.to_mut().set_type_hint(TypeRefTypeHint::PrimitivePtrAsRaw);
 						} else if fld_type_kind.as_class().map_or(false, |cls| cls.kind().is_trait()) {
-							fld_type_ref.set_type_hint(TypeRefTypeHint::TraitClassConcrete);
+							fld_type_ref.to_mut().set_type_hint(TypeRefTypeHint::TraitClassConcrete);
 						}
 						let fld_type_kind = fld_type_ref.kind();
 						let fld_type_ref_return_as_naked = fld_type_kind.return_as_naked(fld_type_ref.type_hint());
@@ -490,7 +490,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.clone(),
+									return_type_ref: fld_type_ref.as_ref().clone(),
 									cpp_body: FuncCppBody::ManualCall("{{name}}".into()),
 									rust_body: FuncRustBody::Auto,
 									rust_extern_definition: FuncRustExtern::Auto,

binding-generator/src/field.rs

@@ -187,9 +187,10 @@ impl<'tu, 'ge> Field<'tu, 'ge> {
 			.filter(|inner| inner.kind().is_copy(inner.type_hint()))
 			.map_or(SliceArgEligibility::NotEligible, |_| {
 				let name = self.cpp_name(CppNameStyle::Declaration);
-				if ARGUMENT_NAMES_NOT_SLICE.contains(name.as_ref()) {
+				let name = name.as_ref();
+				if ARGUMENT_NAMES_NOT_SLICE.contains(name) {
 					SliceArgEligibility::NotEligible
-				} else if ARGUMENT_NAMES_MULTIPLE_SLICE.contains(name.as_ref()) {
+				} else if ARGUMENT_NAMES_MULTIPLE_SLICE.contains(name) {
 					SliceArgEligibility::EligibleWithMultiple
 				} else {
 					SliceArgEligibility::Eligible
@@ -198,17 +199,19 @@ impl<'tu, 'ge> Field<'tu, 'ge> {
 	}
 
 	pub fn can_be_slice_arg_len(&self) -> bool {
-		let name = self.cpp_name(CppNameStyle::Declaration);
 		let type_ref = self.type_ref();
-		type_ref
-			.kind()
-			.as_primitive()
-			.map_or(false, |(_, cpp)| cpp == "int" || cpp == "size_t")
-			&& (name.ends_with('s') && name.contains('n') && name != "thickness" // fixme: have to exclude thickness
-				|| name.contains("dims")
-				|| name == "size"
-				|| name.ends_with("Size")
-				|| name == "len")
+		type_ref.kind().as_primitive().map_or(false, |(_, cpp)| {
+			if cpp == "int" || cpp == "size_t" {
+				let name = self.cpp_name(CppNameStyle::Declaration);
+				name.ends_with('s') && name.contains('n') && name != "thickness" // fixme: have to exclude thickness
+							|| name.contains("dims")
+							|| name == "size"
+							|| name.ends_with("Size")
+							|| name == "len"
+			} else {
+				false
+			}
+		})
 	}
 }
 

binding-generator/src/func.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::borrow::Cow::{Borrowed, Owned};
 use std::collections::HashMap;
 use std::fmt;
 use std::rc::Rc;
@@ -22,8 +23,8 @@ use crate::type_ref::{Constness, CppNameStyle, TypeRefDesc, TypeRefTypeHint};
 use crate::writer::rust_native::element::RustElement;
 use crate::writer::rust_native::type_ref::TypeRefExt;
 use crate::{
-	debug, settings, Class, DefaultElement, Element, EntityExt, Field, GeneratedType, GeneratorEnv, IteratorExt, NameDebug,
-	NameStyle, StrExt, StringExt, TypeRef,
+	debug, settings, Class, CowMapBorrowedExt, DefaultElement, Element, EntityExt, Field, GeneratedType, GeneratorEnv,
+	IteratorExt, NameDebug, NameStyle, StrExt, StringExt, TypeRef,
 };
 
 mod desc;
@@ -120,16 +121,18 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 			FuncKind::GenericInstanceMethod(cls) => FuncKind::InstanceMethod(cls),
 			kind => kind,
 		};
-		let generic = spec
-			.values()
-			.map(|s| s().cpp_name(CppNameStyle::Reference).into_owned())
-			.join(", ");
+		let spec_values = spec.values();
+		let mut generic = String::with_capacity(spec_values.len() * 16);
+		for spec in spec_values {
+			let spec = spec();
+			generic.extend_sep(", ", &spec.cpp_name(CppNameStyle::Reference));
+		}
 		let mut desc = self.to_desc(InheritConfig::empty().kind().arguments().return_type_ref());
 		let desc_mut = Rc::make_mut(&mut desc);
 		desc_mut.kind = kind;
 		desc_mut.type_hint = FuncTypeHint::Specialized;
 		desc_mut.arguments = arguments;
-		desc_mut.return_type_ref = specialized(&return_type_ref).unwrap_or(return_type_ref);
+		desc_mut.return_type_ref = specialized(&return_type_ref).unwrap_or_else(|| return_type_ref.into_owned());
 		desc_mut.cpp_body = FuncCppBody::ManualCall(format!("{{{{name}}}}<{generic}>({{{{args}}}})").into());
 		Self::Desc(desc)
 	}
@@ -160,7 +163,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 				let return_type_ref = if skip_config.return_type_ref {
 					TypeRefDesc::void()
 				} else {
-					self.return_type_ref()
+					self.return_type_ref().into_owned()
 				};
 				let def_loc = if skip_config.definition_location {
 					DefinitionLocation::Generated
@@ -227,7 +230,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 				desc.arguments = ancestor.arguments().into();
 			}
 			if config.return_type_ref {
-				desc.return_type_ref = ancestor.return_type_ref();
+				desc.return_type_ref = ancestor.return_type_ref().into_owned();
 			}
 			if config.definition_location {
 				desc.def_loc = ancestor.file_line_name().location;
@@ -261,7 +264,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 		match self {
 			&Self::Clang { entity, gen_env, .. } => {
 				const OPERATOR: &str = "operator";
-				Cow::Owned(match entity.get_kind() {
+				Owned(match entity.get_kind() {
 					EntityKind::FunctionDecl => {
 						if let Some(operator) = entity.cpp_name(CppNameStyle::Declaration).strip_prefix(OPERATOR) {
 							let arg_count = entity.get_arguments().map_or(0, |v| v.len());
@@ -299,7 +302,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 					_ => unreachable!("Unknown function entity: {:#?}", entity),
 				})
 			}
-			Self::Desc(desc) => Cow::Borrowed(&desc.kind),
+			Self::Desc(desc) => Borrowed(&desc.kind),
 		}
 	}
 
@@ -341,7 +344,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 				const OVERLOAD: &str = "@overload";
 				if let Some(idx) = out.find(OVERLOAD) {
 					let rep = if let Some(copy) = gen_env.get_func_comment(line, self.cpp_name(CppNameStyle::Reference).as_ref()) {
-						Cow::Owned(format!("{copy}\n\n## Overloaded parameters\n"))
+						Owned(format!("{copy}\n\n## Overloaded parameters\n"))
 					} else {
 						"This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.".into()
 					};
@@ -422,7 +425,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 		}
 	}
 
-	pub fn return_type_ref(&self) -> TypeRef<'tu, 'ge> {
+	pub fn return_type_ref(&self) -> Cow<TypeRef<'tu, 'ge>> {
 		match self {
 			&Self::Clang { entity, gen_env, .. } => {
 				let mut out = match self.kind().as_ref() {
@@ -461,9 +464,9 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 				} else if !out.kind().is_char_ptr_string(out.type_hint()) {
 					out.set_type_hint(TypeRefTypeHint::PrimitivePtrAsRaw);
 				}
-				out
+				Owned(out)
 			}
-			Self::Desc(desc) => desc.return_type_ref.clone(),
+			Self::Desc(desc) => Borrowed(&desc.return_type_ref),
 		}
 	}
 
@@ -497,10 +500,10 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 	pub fn arguments(&self) -> Cow<[Field<'tu, 'ge>]> {
 		match self {
 			&Self::Clang { entity, gen_env, .. } => {
-				let mut slice_arg_finder = SliceArgFinder::new();
 				let arg_overrides = settings::ARGUMENT_OVERRIDE.get(&self.func_id());
-				let mut out = self
-					.clang_arguments(entity)
+				let arguments = self.clang_arguments(entity);
+				let mut slice_arg_finder = SliceArgFinder::with_capacity(arguments.len());
+				let mut out = arguments
 					.into_iter()
 					.enumerate()
 					.map(|(idx, a)| {
@@ -527,7 +530,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 					} else {
 						1
 					};
-					slice_len_arg.set_type_ref_type_hint(TypeRefTypeHint::LenForSlice(slice_arg_names, divisor));
+					slice_len_arg.set_type_ref_type_hint(TypeRefTypeHint::LenForSlice(slice_arg_names.into(), divisor));
 				}
 				out.into()
 			}
@@ -567,8 +570,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 		// this to all of the functions, but it's too much work to rename all those entries in FUNC_RENAME
 		if self.is_specialized() {
 			out.push('_');
-			let ret = self.return_type_ref();
-			out.push_str(&ret.cpp_name(CppNameStyle::Reference));
+			out.push_str(&self.return_type_ref().cpp_name(CppNameStyle::Reference));
 		}
 		if self.constness().is_const() {
 			out.push_str("_const");
@@ -673,16 +675,16 @@ impl Element for Func<'_, '_> {
 	fn cpp_namespace(&self) -> Cow<str> {
 		match self {
 			&Self::Clang { entity, .. } => DefaultElement::cpp_namespace(entity).into(),
-			Self::Desc(desc) => match self.kind().as_ref() {
+			Self::Desc(desc) => self.kind().map_borrowed(|kind| match kind {
 				FuncKind::Function | FuncKind::FunctionOperator(_) | FuncKind::GenericFunction => desc.cpp_name.namespace().into(),
 				FuncKind::Constructor(cls)
 				| FuncKind::InstanceMethod(cls)
 				| FuncKind::StaticMethod(cls)
 				| FuncKind::FieldAccessor(cls, _)
 				| FuncKind::ConversionMethod(cls)
 				| FuncKind::InstanceOperator(cls, _)
-				| FuncKind::GenericInstanceMethod(cls) => cls.cpp_name(CppNameStyle::Reference).into_owned().into(),
-			},
+				| FuncKind::GenericInstanceMethod(cls) => cls.cpp_name(CppNameStyle::Reference),
+			}),
 		}
 	}
 

binding-generator/src/func/func_id.rs

@@ -39,7 +39,6 @@ impl<'f> FuncId<'f> {
 	}
 
 	pub fn from_entity(entity: Entity) -> FuncId<'static> {
-		let name = entity.cpp_name(CppNameStyle::Reference).into_owned().into();
 		let args = if let EntityKind::FunctionTemplate = entity.get_kind() {
 			let mut args = Vec::with_capacity(8);
 			entity.walk_children_while(|child| {
@@ -58,7 +57,7 @@ impl<'f> FuncId<'f> {
 				.collect()
 		};
 		FuncId {
-			name,
+			name: entity.cpp_name(CppNameStyle::Reference).into_owned().into(),
 			constness: Constness::from_is_const(entity.is_const_method()),
 			args,
 		}

binding-generator/src/func/slice_arg_finder.rs

@@ -6,9 +6,9 @@ pub struct SliceArgFinder {
 }
 
 impl SliceArgFinder {
-	pub fn new() -> Self {
+	pub fn with_capacity(capacity: usize) -> Self {
 		Self {
-			slice_args: vec![],
+			slice_args: Vec::with_capacity(capacity),
 			state: None,
 		}
 	}

binding-generator/src/function.rs

@@ -4,7 +4,7 @@ use std::fmt;
 use clang::{Entity, EntityKind, EntityVisitResult, Type};
 
 use crate::type_ref::CppNameStyle;
-use crate::{Element, Field, GeneratorEnv, IteratorExt, TypeRef};
+use crate::{CowMapBorrowedExt, Element, Field, GeneratorEnv, IteratorExt, TypeRef};
 
 #[derive(Clone)]
 pub struct Function<'tu, 'ge> {
@@ -58,8 +58,11 @@ impl Element for Function<'_, '_> {
 	fn cpp_name(&self, _style: CppNameStyle) -> Cow<str> {
 		let args = self
 			.arguments()
-			.into_iter()
-			.map(|a| a.type_ref().cpp_name_ext(CppNameStyle::Reference, "", false).into_owned())
+			.iter()
+			.map(|a| {
+				a.type_ref()
+					.map_borrowed(|tref| tref.cpp_name_ext(CppNameStyle::Reference, "", false))
+			})
 			.join(", ");
 		let ret = self.return_type();
 		format!("{ret} (*)({args})", args = args, ret = ret.cpp_name(CppNameStyle::Reference)).into()

binding-generator/src/generator_env.rs

@@ -1,3 +1,4 @@
+use std::cmp::Reverse;
 use std::collections::{HashMap, HashSet};
 use std::convert::TryFrom;
 use std::fmt;
@@ -115,7 +116,7 @@ impl<'tu> GeneratorEnvPopulator<'tu, '_> {
 			let defs = self.gen_env.func_comments.entry(name).or_default();
 			defs.push((line, raw_comment.into_owned()));
 			// reverse sort due to how we're querying this; the amount of elements in this Vec doesn't go above 7
-			defs.sort_unstable_by(|(left_line, _), (right_line, _)| right_line.cmp(left_line));
+			defs.sort_unstable_by_key(|(line, _)| Reverse(*line));
 		}
 	}
 

binding-generator/src/lib.rs

@@ -37,7 +37,7 @@ pub use iterator_ext::IteratorExt;
 use memoize::{MemoizeMap, MemoizeMapExt};
 use name_pool::NamePool;
 use smart_ptr::SmartPtr;
-pub use string_ext::{CompiledInterpolation, StrExt, StringExt};
+pub use string_ext::{CompiledInterpolation, CowMapBorrowedExt, StrExt, StringExt};
 use tuple::Tuple;
 #[allow(unused)]
 use type_ref::dbg_clang_type;

binding-generator/src/name_pool.rs

@@ -20,7 +20,7 @@ impl NamePool {
 			name.to_mut().bump_counter();
 			out = MakeUniqueNameResult::Changed;
 		}
-		self.names.insert(name.clone().into_owned());
+		self.names.insert(name.to_string());
 		out
 	}