Cleanup

Author: twistedfall

binding-generator/src/class.rs

@@ -334,7 +334,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 	pub fn methods(&self) -> Vec<Func<'tu, 'ge>> {
 		let mut out = Vec::with_capacity(32);
 		self.for_each_method(|func| {
-			let func = if let Some(func_fact) = settings::FUNC_REPLACE.get(&func.func_id()) {
+			let func: Func = if let Some(func_fact) = settings::FUNC_REPLACE.get(&func.func_id()) {
 				func_fact(&func)
 			} else {
 				func

binding-generator/src/func.rs

@@ -321,16 +321,21 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 	}
 
 	pub fn is_generic(&self) -> bool {
-		match self.kind().as_ref() {
-			FuncKind::GenericFunction | FuncKind::GenericInstanceMethod(..) => true,
-			FuncKind::Function
-			| FuncKind::Constructor(..)
-			| FuncKind::InstanceMethod(..)
-			| FuncKind::StaticMethod(..)
-			| FuncKind::FieldAccessor(..)
-			| FuncKind::ConversionMethod(..)
-			| FuncKind::FunctionOperator(..)
-			| FuncKind::InstanceOperator(..) => false,
+		match self {
+			Func::Clang { entity, .. } => {
+				matches!(entity.get_kind(), EntityKind::FunctionTemplate)
+			}
+			Func::Desc(desc) => match desc.kind {
+				FuncKind::GenericFunction | FuncKind::GenericInstanceMethod(..) => true,
+				FuncKind::Function
+				| FuncKind::Constructor(..)
+				| FuncKind::InstanceMethod(..)
+				| FuncKind::StaticMethod(..)
+				| FuncKind::FieldAccessor(..)
+				| FuncKind::ConversionMethod(..)
+				| FuncKind::FunctionOperator(..)
+				| FuncKind::InstanceOperator(..) => false,
+			},
 		}
 	}
 
@@ -461,7 +466,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 								.iter()
 								.find(|arg| arg.cpp_name(CppNameStyle::Declaration) == *borrow_arg_name)
 								.map(|arg| arg.type_ref().constness())
-								.unwrap_or_else(|| panic!("BoxedAsRef refers to the non-existent argument name: {}", borrow_arg_name))
+								.unwrap_or_else(|| panic!("BoxedAsRef refers to the non-existent argument name: {borrow_arg_name}"))
 						};
 						out.set_inherent_constness(borrow_arg_constness);
 					}
@@ -536,9 +541,9 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 					};
 					slice_len_arg.set_type_ref_type_hint(TypeRefTypeHint::LenForSlice(slice_arg_names.into(), divisor));
 				}
-				out.into()
+				Owned(out)
 			}
-			Self::Desc(desc) => desc.arguments.as_ref().into(),
+			Self::Desc(desc) => Borrowed(desc.arguments.as_ref()),
 		}
 	}
 
@@ -572,6 +577,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 		};
 		// add return type to function id for cases when we specialize on the return type, in theory we should be able to apply
 		// this to all of the functions, but it's too much work to rename all those entries in FUNC_RENAME
+		// fixme: introduce FuncMatcher and use this logic for every function and not only specialized ones
 		if self.is_specialized() {
 			out.push('_');
 			out.push_str(&self.return_type_ref().cpp_name(CppNameStyle::Reference));

binding-generator/src/func/kind.rs

@@ -129,6 +129,7 @@ pub enum FuncKind<'tu, 'ge> {
 }
 
 impl<'tu, 'ge> FuncKind<'tu, 'ge> {
+	#[inline]
 	pub fn as_instance_method(&self) -> Option<&Class<'tu, 'ge>> {
 		match self {
 			Self::InstanceMethod(out)
@@ -140,6 +141,7 @@ impl<'tu, 'ge> FuncKind<'tu, 'ge> {
 		}
 	}
 
+	#[inline]
 	pub fn as_constructor(&self) -> Option<&Class<'tu, 'ge>> {
 		if let Self::Constructor(out) = self {
 			Some(out)
@@ -148,6 +150,7 @@ impl<'tu, 'ge> FuncKind<'tu, 'ge> {
 		}
 	}
 
+	#[inline]
 	pub fn as_static_method(&self) -> Option<&Class<'tu, 'ge>> {
 		if let Self::StaticMethod(out) = self {
 			Some(out)
@@ -156,6 +159,7 @@ impl<'tu, 'ge> FuncKind<'tu, 'ge> {
 		}
 	}
 
+	#[inline]
 	pub fn as_conversion_method(&self) -> Option<&Class<'tu, 'ge>> {
 		if let Self::ConversionMethod(out) = self {
 			Some(out)
@@ -164,6 +168,7 @@ impl<'tu, 'ge> FuncKind<'tu, 'ge> {
 		}
 	}
 
+	#[inline]
 	/// Any function with a connection to a class: instance method, static method or a constructor
 	pub fn as_class_method(&self) -> Option<&Class<'tu, 'ge>> {
 		self
@@ -172,6 +177,7 @@ impl<'tu, 'ge> FuncKind<'tu, 'ge> {
 			.or_else(|| self.as_static_method())
 	}
 
+	#[inline]
 	pub fn as_operator(&self) -> Option<(Option<&Class<'tu, 'ge>>, OperatorKind)> {
 		match self {
 			Self::FunctionOperator(kind) => Some((None, *kind)),
@@ -180,6 +186,7 @@ impl<'tu, 'ge> FuncKind<'tu, 'ge> {
 		}
 	}
 
+	#[inline]
 	pub fn as_field_accessor(&self) -> Option<(&Class<'tu, 'ge>, &Field<'tu, 'ge>)> {
 		if let FuncKind::FieldAccessor(cls, fld) = self {
 			Some((cls, fld))

binding-generator/src/lib.rs

@@ -12,8 +12,6 @@
 
 #![allow(clippy::nonminimal_bool)] // pattern `!type_ref.as_vector().is_some()` used for more clarity
 
-extern crate core;
-
 use std::borrow::Cow;
 use std::fs::File;
 use std::io::{BufRead, Read, Seek, SeekFrom};
@@ -33,10 +31,11 @@ pub use func::{Func, FuncId, FuncTypeHint};
 pub use generator::{GeneratedType, Generator, GeneratorVisitor, OpenCvWalker};
 pub use generator_env::{ClassKindOverride, ExportConfig, GeneratorEnv};
 pub use iterator_ext::IteratorExt;
+pub use map_borrowed::CowMapBorrowedExt;
 use memoize::{MemoizeMap, MemoizeMapExt};
 use name_pool::NamePool;
 use smart_ptr::SmartPtr;
-pub use string_ext::{CompiledInterpolation, CowMapBorrowedExt, StrExt, StringExt};
+pub use string_ext::{CompiledInterpolation, StrExt, StringExt};
 use tuple::Tuple;
 #[allow(unused)]
 use type_ref::dbg_clang_type;
@@ -62,6 +61,7 @@ mod function;
 mod generator;
 mod generator_env;
 mod iterator_ext;
+mod map_borrowed;
 mod memoize;
 mod name_pool;
 mod renderer;

binding-generator/src/map_borrowed.rs

@@ -0,0 +1,28 @@
+use std::borrow::{Borrow, Cow};
+
+pub trait CowMapBorrowedExt<'c, 'b, IN, OUT>
+where
+	IN: ToOwned + ?Sized + 'b,
+	OUT: ToOwned + ?Sized + 'b,
+{
+	fn map_borrowed<F>(self, f: F) -> Cow<'c, OUT>
+	where
+		F: for<'f> FnOnce(&'f IN) -> Cow<'f, OUT>;
+}
+
+impl<'c, 'b, IN, OUT> CowMapBorrowedExt<'c, 'b, IN, OUT> for Cow<'c, IN>
+where
+	IN: ToOwned + ?Sized + 'b,
+	OUT: ToOwned + ?Sized + 'b,
+{
+	#[inline(always)]
+	fn map_borrowed<F>(self, f: F) -> Cow<'c, OUT>
+	where
+		F: for<'f> FnOnce(&'f IN) -> Cow<'f, OUT>,
+	{
+		match self {
+			Cow::Borrowed(v) => f(v),
+			Cow::Owned(v) => Cow::Owned(f(v.borrow()).into_owned()),
+		}
+	}
+}

binding-generator/src/renderer.rs

@@ -171,7 +171,7 @@ impl<'a> TypeRefRenderer<'a> for CppExternReturnRenderer {
 		let type_ref = if kind.as_string(type_ref.type_hint()).is_some() {
 			Cow::Owned(TypeRef::new_pointer(TypeRefDesc::void()))
 		} else if kind.extern_pass_kind().is_by_void_ptr() && !kind.as_abstract_class_ptr().is_some() {
-			Cow::Owned(TypeRef::new_pointer(type_ref.source()))
+			Cow::Owned(TypeRef::new_pointer(type_ref.source().into_owned()))
 		} else {
 			Cow::Borrowed(type_ref)
 		};

binding-generator/src/string_ext.rs

@@ -1,4 +1,4 @@
-use std::borrow::{Borrow, Cow};
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::iter;
 
@@ -537,30 +537,3 @@ impl StrExt for str {
 		}
 	}
 }
-
-pub trait CowMapBorrowedExt<'b, IN, OUT>
-where
-	IN: 'b + ToOwned + ?Sized,
-	OUT: 'b + ToOwned + ?Sized,
-{
-	fn map_borrowed<F>(self, f: F) -> Cow<'b, OUT>
-	where
-		F: for<'f> FnOnce(&'f IN) -> Cow<'f, OUT>;
-}
-
-impl<'b, IN, OUT> CowMapBorrowedExt<'b, IN, OUT> for Cow<'b, IN>
-where
-	IN: 'b + ToOwned + ?Sized,
-	OUT: 'b + ToOwned + ?Sized,
-{
-	#[inline(always)]
-	fn map_borrowed<F>(self, f: F) -> Cow<'b, OUT>
-	where
-		F: for<'f> FnOnce(&'f IN) -> Cow<'f, OUT>,
-	{
-		match self {
-			Cow::Borrowed(v) => f(v),
-			Cow::Owned(v) => Cow::Owned(f(v.borrow()).into_owned()),
-		}
-	}
-}

binding-generator/src/type_ref.rs

@@ -164,27 +164,29 @@ impl<'tu, 'ge> TypeRef<'tu, 'ge> {
 	}
 
 	/// TypeRef with all the typedef's traversed
-	pub fn canonical(&self) -> Self {
+	pub fn canonical(&self) -> Cow<Self> {
 		match self.kind().as_ref() {
-			TypeRefKind::Typedef(tdef) => tdef.underlying_type_ref().canonical(),
-			_ => self.clone(),
+			TypeRefKind::Typedef(tdef) => Owned(tdef.underlying_type_ref().canonical().into_owned()),
+			_ => Borrowed(self),
 		}
 	}
 
 	/// Removes indirection by pointer and reference, this will also remove typedef if it references a pointer or reference
-	pub fn source(&self) -> Self {
+	pub fn source(&self) -> Cow<Self> {
 		match self.kind().as_ref() {
-			TypeRefKind::Pointer(inner) | TypeRefKind::Reference(inner) | TypeRefKind::RValueReference(inner) => inner.source(),
+			TypeRefKind::Pointer(inner) | TypeRefKind::Reference(inner) | TypeRefKind::RValueReference(inner) => {
+				Owned(inner.source().into_owned())
+			}
 			TypeRefKind::Typedef(tdef) => {
 				let underlying_type = tdef.underlying_type_ref();
 				match underlying_type.kind().as_ref() {
 					TypeRefKind::Pointer(inner) | TypeRefKind::Reference(inner) | TypeRefKind::RValueReference(inner) => {
-						inner.source()
+						Owned(inner.source().into_owned())
 					}
-					_ => self.clone(),
+					_ => Borrowed(self),
 				}
 			}
-			_ => self.clone(),
+			_ => Borrowed(self),
 		}
 	}
 

binding-generator/src/type_ref/desc.rs

@@ -379,7 +379,7 @@ impl<'tu> ClangTypeExt<'tu> for Type<'tu> {
 			match kind {
 				TypeKind::Pointer => {
 					let pointee = self.get_pointee_type().expect("No pointee type for pointer");
-					let pointee_typeref = TypeRef::new_ext(pointee, type_hint.recurse(), parent_entity, gen_env);
+					let pointee_typeref = TypeRef::new_ext(pointee, type_hint.recurse_inner(), parent_entity, gen_env);
 					let pointee_kind = pointee_typeref.kind();
 					if pointee_kind.is_function() {
 						pointee_kind.into_owned()
@@ -392,7 +392,7 @@ impl<'tu> ClangTypeExt<'tu> for Type<'tu> {
 
 				TypeKind::LValueReference => TypeRefKind::Reference(TypeRef::new_ext(
 					self.get_pointee_type().expect("No pointee type for reference"),
-					type_hint.recurse(),
+					type_hint.recurse_inner(),
 					parent_entity,
 					gen_env,
 				)),

binding-generator/src/type_ref/kind.rs

@@ -488,7 +488,7 @@ pub enum InputOutputArrayKind {
 }
 
 #[cfg(test)]
-mod tests {
+mod test {
 	use crate::type_ref::{Dir, StrEnc, StrType, TypeRef, TypeRefDesc, TypeRefTypeHint};
 
 	fn as_string(type_ref: TypeRef) -> Option<(Dir, StrType)> {