Drop separate TypeRefTypeHint and FieldTypeHint

binding-generator/src/class.rs

@@ -12,9 +12,10 @@ use crate::comment::strip_comment_markers;
 use crate::debug::{DefinitionLocation, LocationName};
 use crate::element::ExcludeKind;
 use crate::entity::{WalkAction, WalkResult};
-use crate::field::{FieldDesc, FieldTypeHint};
+use crate::field::FieldDesc;
 use crate::func::{FuncCppBody, FuncDesc, FuncKind, FuncRustBody, FuncRustExtern, ReturnKind};
-use crate::type_ref::{Constness, CppNameStyle, StrEnc, StrType, TypeRef, TypeRefDesc, TypeRefTypeHint};
+use crate::type_ref::TypeRefTypeHint;
+use crate::type_ref::{Constness, CppNameStyle, StrEnc, StrType, TypeRef, TypeRefDesc};
 use crate::writer::rust_native::element::RustElement;
 use crate::{
 	settings, ClassSimplicity, Const, DefaultElement, Element, EntityExt, Enum, Field, Func, FuncTypeHint, GeneratedType,
@@ -501,7 +502,7 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 								arguments: Rc::new([Field::new_desc(FieldDesc {
 									cpp_fullname: "val".into(),
 									type_ref: fld_type_ref.with_inherent_constness(Constness::Const),
-									type_hint: FieldTypeHint::None,
+									type_ref_type_hint: TypeRefTypeHint::None,
 									default_value: fld.default_value().map(|v| v.into()),
 								})]),
 								return_kind: ReturnKind::InfallibleNaked,

binding-generator/src/field.rs

@@ -11,35 +11,29 @@ use clang::{Entity, EntityKind, EntityVisitResult};
 use crate::comment::strip_comment_markers;
 use crate::debug::{DefinitionLocation, LocationName, NameDebug};
 use crate::element::ExcludeKind;
-use crate::settings::{ArgOverride, ARGUMENT_NAMES_MULTIPLE_SLICE, ARGUMENT_NAMES_NOT_SLICE, ARGUMENT_NAMES_USERDATA};
+use crate::settings::{ARGUMENT_NAMES_MULTIPLE_SLICE, ARGUMENT_NAMES_NOT_SLICE, ARGUMENT_NAMES_USERDATA};
 use crate::type_ref::{Constness, CppNameStyle, TypeRef, TypeRefKind, TypeRefTypeHint};
 use crate::{constant, DefaultElement, Element, GeneratorEnv, StrExt};
 
-#[derive(Clone, Debug, PartialEq)]
-pub enum FieldTypeHint {
-	None,
-	ArgOverride(ArgOverride),
-}
-
 #[derive(Clone)]
 pub enum Field<'tu, 'ge> {
 	Clang {
 		entity: Entity<'tu>,
-		type_hint: FieldTypeHint,
+		type_ref_type_hint: TypeRefTypeHint,
 		gen_env: &'ge GeneratorEnv<'tu>,
 	},
 	Desc(Rc<FieldDesc<'tu, 'ge>>),
 }
 
 impl<'tu, 'ge> Field<'tu, 'ge> {
 	pub fn new(entity: Entity<'tu>, gen_env: &'ge GeneratorEnv<'tu>) -> Self {
-		Self::new_ext(entity, FieldTypeHint::None, gen_env)
+		Self::new_ext(entity, TypeRefTypeHint::None, gen_env)
 	}
 
-	pub fn new_ext(entity: Entity<'tu>, type_hint: FieldTypeHint, gen_env: &'ge GeneratorEnv<'tu>) -> Self {
+	pub fn new_ext(entity: Entity<'tu>, type_ref_type_hint: TypeRefTypeHint, gen_env: &'ge GeneratorEnv<'tu>) -> Self {
 		Self::Clang {
 			entity,
-			type_hint,
+			type_ref_type_hint,
 			gen_env,
 		}
 	}
@@ -48,47 +42,47 @@ impl<'tu, 'ge> Field<'tu, 'ge> {
 		Self::Desc(Rc::new(desc))
 	}
 
-	pub fn type_hint(&self) -> &FieldTypeHint {
+	pub fn type_ref_type_hint(&self) -> &TypeRefTypeHint {
 		match self {
-			Self::Clang { type_hint, .. } => type_hint,
-			Self::Desc(desc) => &desc.type_hint,
+			Self::Clang { type_ref_type_hint, .. } => type_ref_type_hint,
+			Self::Desc(desc) => &desc.type_ref_type_hint,
 		}
 	}
 
-	pub fn set_type_hint(&mut self, type_hint: FieldTypeHint) {
+	pub fn set_type_ref_type_hint(&mut self, type_ref_type_hint: TypeRefTypeHint) {
 		match self {
 			Self::Clang {
-				type_hint: old_type_hint,
+				type_ref_type_hint: old_type_ref_type_hint,
 				..
-			} => *old_type_hint = type_hint,
-			Self::Desc(desc) => Rc::make_mut(desc).type_hint = type_hint,
+			} => *old_type_ref_type_hint = type_ref_type_hint,
+			Self::Desc(desc) => Rc::make_mut(desc).type_ref_type_hint = type_ref_type_hint,
 		}
 	}
 
 	pub fn type_ref(&self) -> Cow<TypeRef<'tu, 'ge>> {
 		match self {
 			Self::Clang {
 				entity,
-				type_hint,
+				type_ref_type_hint,
 				gen_env,
 				..
 			} => {
-				let type_hint = match type_hint {
-					FieldTypeHint::ArgOverride(over) => TypeRefTypeHint::ArgOverride(over.clone()),
-					_ => {
+				let type_ref_type_hint = match type_ref_type_hint {
+					TypeRefTypeHint::None => {
 						let default_value_string = self
 							.default_value()
 							.map_or(false, |def| def.contains(|c| c == '"' || c == '\''));
 						if default_value_string {
-							TypeRefTypeHint::ArgOverride(ArgOverride::CharAsRustChar)
+							TypeRefTypeHint::CharAsRustChar
 						} else {
 							TypeRefTypeHint::None
 						}
 					}
+					type_ref_type_hint => type_ref_type_hint.clone(),
 				};
 				Cow::Owned(TypeRef::new_ext(
 					entity.get_type().expect("Can't get type"),
-					type_hint,
+					type_ref_type_hint,
 					Some(*entity),
 					gen_env,
 				))
@@ -185,7 +179,7 @@ impl<'tu, 'ge> Field<'tu, 'ge> {
 	}
 
 	pub fn as_slice_len(&self) -> Option<(&[String], usize)> {
-		if let FieldTypeHint::ArgOverride(ArgOverride::LenForSlice(ptr_arg, len_div)) = self.type_hint() {
+		if let TypeRefTypeHint::LenForSlice(ptr_arg, len_div) = self.type_ref_type_hint() {
 			Some((ptr_arg.as_slice(), *len_div))
 		} else {
 			None
@@ -250,7 +244,7 @@ impl fmt::Debug for Field<'_, '_> {
 			Self::Desc(_) => "Field::Desc",
 		})
 		.field("cpp_fullname", &self.cpp_name(CppNameStyle::Reference))
-		.field("type_hint", &self.type_hint())
+		.field("type_ref_type_hint", &self.type_ref_type_hint())
 		.field("type_ref", &self.type_ref())
 		.field("default_value", &self.default_value())
 		.finish()
@@ -261,7 +255,7 @@ impl fmt::Debug for Field<'_, '_> {
 pub struct FieldDesc<'tu, 'ge> {
 	pub cpp_fullname: Rc<str>,
 	pub type_ref: TypeRef<'tu, 'ge>,
-	pub type_hint: FieldTypeHint,
+	pub type_ref_type_hint: TypeRefTypeHint,
 	pub default_value: Option<Rc<str>>,
 }
 
@@ -270,7 +264,7 @@ impl<'tu, 'ge> FieldDesc<'tu, 'ge> {
 		Self {
 			cpp_fullname: name.into(),
 			type_ref,
-			type_hint: FieldTypeHint::None,
+			type_ref_type_hint: TypeRefTypeHint::None,
 			default_value: None,
 		}
 	}

binding-generator/src/func.rs

@@ -15,12 +15,12 @@ use crate::debug::{DefinitionLocation, LocationName};
 use crate::element::ExcludeKind;
 use crate::entity::WalkAction;
 use crate::field::FieldDesc;
-use crate::settings::{ArgOverride, TypeRefFactory, RETURN_HINT};
+use crate::settings::{TypeRefFactory, RETURN_HINT};
 use crate::type_ref::{Constness, CppNameStyle, TypeRefDesc, TypeRefTypeHint};
 use crate::writer::rust_native::element::RustElement;
 use crate::{
-	settings, Class, DefaultElement, Element, EntityExt, Field, FieldTypeHint, GeneratedType, GeneratorEnv, IteratorExt,
-	NameDebug, NameStyle, StrExt, StringExt, TypeRef,
+	settings, Class, DefaultElement, Element, EntityExt, Field, GeneratedType, GeneratorEnv, IteratorExt, NameDebug, NameStyle,
+	StrExt, StringExt, TypeRef,
 };
 pub use func_id::FuncId;
 pub use kind::{FuncKind, OperatorKind, ReturnKind};
@@ -108,7 +108,7 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 						Field::new_desc(FieldDesc {
 							cpp_fullname: arg.cpp_name(CppNameStyle::Reference).into(),
 							type_ref,
-							type_hint: FieldTypeHint::None,
+							type_ref_type_hint: TypeRefTypeHint::None,
 							default_value: arg.default_value().map(|v| v.into()),
 						})
 					},
@@ -453,11 +453,11 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 						None,
 						gen_env,
 					);
-					if let Some(over) = settings::ARGUMENT_OVERRIDE
+					if let Some(type_hint) = settings::ARGUMENT_OVERRIDE
 						.get(&self.func_id())
 						.and_then(|x| x.get(RETURN_HINT))
 					{
-						out = out.with_type_hint(TypeRefTypeHint::ArgOverride(over.clone()))
+						out = out.with_type_hint(type_hint.clone())
 					}
 					if let Some(type_ref) = out.as_reference() {
 						type_ref
@@ -507,9 +507,10 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 					.into_iter()
 					.enumerate()
 					.map(|(idx, a)| {
-						let arg_override = arg_overrides.and_then(|o| a.get_name().and_then(|arg_name| o.get(arg_name.as_str())));
-						if let Some(arg_override) = arg_override {
-							return Field::new_ext(a, FieldTypeHint::ArgOverride(arg_override.clone()), gen_env);
+						if let Some(func_arg_override) = arg_overrides {
+							if let Some(type_hint) = a.get_name().and_then(|arg_name| func_arg_override.get(arg_name.as_str())) {
+								return Field::new_ext(a, type_hint.clone(), gen_env);
+							}
 						}
 						let out = Field::new(a, gen_env);
 						slice_arg_finder.feed(idx, &out);
@@ -521,15 +522,15 @@ impl<'tu, 'ge> Func<'tu, 'ge> {
 					for &slice_arg_idx in &slice_arg_indices {
 						let slice_arg = &mut out[slice_arg_idx];
 						slice_arg_names.push(slice_arg.rust_name(NameStyle::ref_()).into_owned());
-						slice_arg.set_type_hint(FieldTypeHint::ArgOverride(ArgOverride::Slice));
+						slice_arg.set_type_ref_type_hint(TypeRefTypeHint::Slice);
 					}
 					let slice_len_arg = &mut out[slice_len_arg_idx];
 					let divisor = if slice_len_arg.cpp_name(CppNameStyle::Declaration).contains("pair") {
 						2
 					} else {
 						1
 					};
-					slice_len_arg.set_type_hint(FieldTypeHint::ArgOverride(ArgOverride::LenForSlice(slice_arg_names, divisor)));
+					slice_len_arg.set_type_ref_type_hint(TypeRefTypeHint::LenForSlice(slice_arg_names, divisor));
 				}
 				out.into()
 			}

binding-generator/src/lib.rs

@@ -28,7 +28,7 @@ pub use element::{is_opencv_path, opencv_module_from_path, DefaultElement, Eleme
 use entity::dbg_clang_entity;
 pub use entity::{EntityExt, WalkAction, WalkResult};
 pub use enumeration::Enum;
-use field::{Field, FieldTypeHint};
+use field::Field;
 pub use func::{Func, FuncId, FuncTypeHint};
 use function::Function;
 pub use generator::{GeneratedType, Generator, GeneratorVisitor};

binding-generator/src/settings.rs

@@ -5,7 +5,7 @@ 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::{ArgOverride, ARGUMENT_OVERRIDE, RETURN_HINT};
+pub use argument_override::{ARGUMENT_OVERRIDE, RETURN_HINT};
 pub use element_exclude_kind::ELEMENT_EXCLUDE_KIND;
 pub use element_export_tweak::ELEMENT_EXPORT_TWEAK;
 pub use force_infallible::FORCE_INFALLIBLE;