Split out TypeRef renderers into a separate module, improve const handling

Author: twistedfall

binding-generator/src/class.rs

@@ -254,7 +254,7 @@ impl<'tu> Class<'tu> {
 				iter::from_fn({
 					let fld_type_ref = fld.type_ref();
 					let mut need_to_yield_read = true;
-					let mut need_to_yield_write = !fld_type_ref.is_const() && !fld_type_ref.as_fixed_array().is_some();
+					let mut need_to_yield_write = !fld_type_ref.constness().is_const() && !fld_type_ref.as_fixed_array().is_some();
 					move || {
 						if need_to_yield_read {
 							need_to_yield_read = false;

binding-generator/src/func.rs

@@ -249,7 +249,7 @@ impl<'tu> Func<'tu> {
 		else if let Some(fld) = self.as_field_accessor() {
 			self.type_hint != FunctionTypeHint::FieldSetter && {
 				let type_ref = fld.type_ref();
-				type_ref.is_const() || type_ref.is_copy() || matches!(type_ref.as_string(), Some(Dir::In(StrType::CvString)) | Some(Dir::In(StrType::StdString)))
+				type_ref.constness().is_const() || type_ref.is_copy() || matches!(type_ref.as_string(), Some(Dir::In(StrType::CvString)) | Some(Dir::In(StrType::StdString)))
 			}
 		} else {
 			self.entity.is_const_method()
@@ -596,7 +596,7 @@ impl Element for Func<'_> {
 					});
 					if let Some(other) = class_arg {
 						if cls == other {
-							break 'ctor_name if arg_typeref.is_const() {
+							break 'ctor_name if arg_typeref.constness().is_const() {
 								"copy"
 							} else {
 								"copy_mut"

binding-generator/src/function.rs

@@ -87,7 +87,7 @@ impl Element for Function<'_> {
 
 	fn cpp_localname(&self) -> Cow<str> {
 		let args = self.arguments().into_iter()
-			.map(|a| a.type_ref().cpp_full_native("").into_owned())
+			.map(|a| a.type_ref().cpp_full_ext("", false).into_owned())
 			.join(", ");
 		let ret = self.return_type();
 		format!("{ret} (*)({args})", args=args, ret=ret.cpp_full()).into()

binding-generator/src/lib.rs

@@ -50,7 +50,7 @@ use name_pool::NamePool;
 use return_type_wrapper::{DefinitionLocation, ReturnTypeWrapper};
 use smart_ptr::SmartPtr;
 pub use string_ext::{CompiledInterpolation, StrExt, StringExt};
-use type_ref::{Constness, DependentTypeMode, TypeRef, TypeRefTypeHint};
+use type_ref::{Constness, ConstnessOverride, DependentTypeMode, TypeRef, TypeRefTypeHint};
 pub use typedef::Typedef;
 use vector::Vector;
 pub use walker::{EntityWalker, EntityWalkerVisitor};

binding-generator/src/return_type_wrapper.rs

@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 
 use crate::{
+	ConstnessOverride,
 	GeneratorEnv,
 	TypeRef,
 };
@@ -15,25 +16,25 @@ pub enum DefinitionLocation {
 #[derive(Debug)]
 pub struct ReturnTypeWrapper<'tu> {
 	type_ref: TypeRef<'tu>,
-	const_hint: Option<bool>,
+	const_hint: ConstnessOverride,
 	definition_location: DefinitionLocation,
 	gen_env: &'tu GeneratorEnv<'tu>,
 }
 
 impl<'tu> ReturnTypeWrapper<'tu> {
 	pub fn new(type_ref: TypeRef<'tu>, definition_location: DefinitionLocation, gen_env: &'tu GeneratorEnv<'tu>) -> Self {
-		Self::new_ext(type_ref, None, definition_location, gen_env)
+		Self::new_ext(type_ref, ConstnessOverride::No, definition_location, gen_env)
 	}
 
-	pub fn new_ext(type_ref: TypeRef<'tu>, const_hint: Option<bool>, definition_location: DefinitionLocation, gen_env: &'tu GeneratorEnv<'tu>) -> Self {
+	pub fn new_ext(type_ref: TypeRef<'tu>, const_hint: ConstnessOverride, definition_location: DefinitionLocation, gen_env: &'tu GeneratorEnv<'tu>) -> Self {
 		Self { type_ref, const_hint, definition_location, gen_env }
 	}
 
 	pub fn type_ref(&self) -> &TypeRef<'tu> {
 		&self.type_ref
 	}
 
-	pub fn const_hint(&self) -> Option<bool> {
+	pub fn const_hint(&self) -> ConstnessOverride {
 		self.const_hint
 	}
 

binding-generator/src/smart_ptr.rs

@@ -104,7 +104,7 @@ impl Element for SmartPtr<'_> {
 	}
 
 	fn rust_leafname(&self) -> Cow<str> {
-		format!("Ptr::<{typ}>", typ=self.pointee().rust_full()).into()
+		format!("Ptr::<{typ}>", typ=self.pointee().rust_full_ext(true, true)).into()
 	}
 
 	fn rust_localname(&self) -> Cow<str> {