Merge pull request #883 from sdroege/value-from-type

GuillaumeGomez · web-flow · commit 5091b7debd05 · 2023-01-05T18:50:55.000+01:00
glib: Add Value::from_type_unchecked()
diff --git a/cairo/src/lib.rs b/cairo/src/lib.rs
@@ -72,8 +72,9 @@ macro_rules! gvalue_impl {
         impl glib::value::ToValue for $name {
             fn to_value(&self) -> glib::Value {
                 unsafe {
-                    let mut value =
-                        glib::Value::from_type(<$name as glib::StaticType>::static_type());
+                    let mut value = glib::Value::from_type_unchecked(
+                        <$name as glib::StaticType>::static_type(),
+                    );
                     glib::gobject_ffi::g_value_take_boxed(
                         value.to_glib_none_mut().0,
                         self.to_glib_full() as *mut _,
@@ -90,8 +91,9 @@ macro_rules! gvalue_impl {
         impl From<$name> for glib::Value {
             fn from(v: $name) -> Self {
                 unsafe {
-                    let mut value =
-                        glib::Value::from_type(<$name as glib::StaticType>::static_type());
+                    let mut value = glib::Value::from_type_unchecked(
+                        <$name as glib::StaticType>::static_type(),
+                    );
                     glib::gobject_ffi::g_value_take_boxed(
                         value.to_glib_none_mut().0,
                         glib::translate::IntoGlibPtr::into_glib_ptr(v) as *mut _,
@@ -154,8 +156,9 @@ macro_rules! gvalue_impl_inline {
                     let ptr =
                         glib::ffi::g_malloc0(std::mem::size_of::<$ffi_name>()) as *mut $ffi_name;
                     ptr.write(self.0);
-                    let mut value =
-                        glib::Value::from_type(<$name as glib::StaticType>::static_type());
+                    let mut value = glib::Value::from_type_unchecked(
+                        <$name as glib::StaticType>::static_type(),
+                    );
                     glib::gobject_ffi::g_value_take_boxed(
                         value.to_glib_none_mut().0,
                         ptr as *mut _,
diff --git a/glib-macros/src/boxed_derive.rs b/glib-macros/src/boxed_derive.rs
@@ -153,7 +153,7 @@ pub fn impl_boxed(input: &syn::DeriveInput) -> TokenStream {
             fn to_value(&self) -> #crate_ident::Value {
                 unsafe {
                     let ptr: *mut #name = ::std::boxed::Box::into_raw(::std::boxed::Box::new(self.clone()));
-                    let mut value = #crate_ident::Value::from_type(<#name as #crate_ident::StaticType>::static_type());
+                    let mut value = #crate_ident::Value::from_type_unchecked(<#name as #crate_ident::StaticType>::static_type());
                     #crate_ident::gobject_ffi::g_value_take_boxed(
                         #crate_ident::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         ptr as *mut _
@@ -172,7 +172,7 @@ pub fn impl_boxed(input: &syn::DeriveInput) -> TokenStream {
             #[inline]
             fn from(v: #name) -> Self {
                 unsafe {
-                    let mut value = #crate_ident::Value::from_type(<#name as #crate_ident::StaticType>::static_type());
+                    let mut value = #crate_ident::Value::from_type_unchecked(<#name as #crate_ident::StaticType>::static_type());
                     #crate_ident::gobject_ffi::g_value_take_boxed(
                         #crate_ident::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         #crate_ident::translate::IntoGlibPtr::<*mut #name>::into_glib_ptr(v) as *mut _,
diff --git a/glib-macros/src/shared_boxed_derive.rs b/glib-macros/src/shared_boxed_derive.rs
@@ -174,7 +174,7 @@ pub fn impl_shared_boxed(input: &syn::DeriveInput) -> proc_macro2::TokenStream {
             fn to_value(&self) -> #crate_ident::Value {
                 unsafe {
                     let ptr = #refcounted_type_prefix::into_raw(self.0.clone());
-                    let mut value = #crate_ident::Value::from_type(<#name as #crate_ident::StaticType>::static_type());
+                    let mut value = #crate_ident::Value::from_type_unchecked(<#name as #crate_ident::StaticType>::static_type());
                     #crate_ident::gobject_ffi::g_value_take_boxed(
                         #crate_ident::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         ptr as *mut _
@@ -193,7 +193,7 @@ pub fn impl_shared_boxed(input: &syn::DeriveInput) -> proc_macro2::TokenStream {
             #[inline]
             fn from(v: #name) -> Self {
                 unsafe {
-                    let mut value = #crate_ident::Value::from_type(<#name as #crate_ident::StaticType>::static_type());
+                    let mut value = #crate_ident::Value::from_type_unchecked(<#name as #crate_ident::StaticType>::static_type());
                     #crate_ident::gobject_ffi::g_value_take_boxed(
                         #crate_ident::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         #crate_ident::translate::IntoGlibPtr::<*mut #refcounted_type_prefix::InnerType>::into_glib_ptr(v) as *mut _,
diff --git a/glib/src/boxed.rs b/glib/src/boxed.rs
@@ -344,7 +344,7 @@ macro_rules! glib_boxed_wrapper {
             #[inline]
             fn to_value(&self) -> $crate::Value {
                 unsafe {
-                    let mut value = $crate::Value::from_type(<Self as $crate::StaticType>::static_type());
+                    let mut value = $crate::Value::from_type_unchecked(<Self as $crate::StaticType>::static_type());
                     $crate::gobject_ffi::g_value_take_boxed(
                         $crate::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         $crate::translate::ToGlibPtr::<*const $ffi_name>::to_glib_full(self) as *mut _,
@@ -363,7 +363,7 @@ macro_rules! glib_boxed_wrapper {
             #[inline]
             fn from(o: $name $(<$($generic),+>)?) -> Self {
                 unsafe {
-                    let mut value = $crate::Value::from_type(<$name $(<$($generic),+>)? as $crate::StaticType>::static_type());
+                    let mut value = $crate::Value::from_type_unchecked(<$name $(<$($generic),+>)? as $crate::StaticType>::static_type());
                     $crate::gobject_ffi::g_value_take_boxed(
                         $crate::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         $crate::translate::IntoGlibPtr::<*mut $ffi_name>::into_glib_ptr(o) as *mut _,
diff --git a/glib/src/boxed_inline.rs b/glib/src/boxed_inline.rs
@@ -588,7 +588,7 @@ macro_rules! glib_boxed_inline_wrapper {
             #[inline]
             fn to_value(&self) -> $crate::Value {
                 unsafe {
-                    let mut value = $crate::Value::from_type(<Self as $crate::StaticType>::static_type());
+                    let mut value = $crate::Value::from_type_unchecked(<Self as $crate::StaticType>::static_type());
                     $crate::gobject_ffi::g_value_set_boxed(
                         $crate::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         $crate::translate::ToGlibPtr::<*const $ffi_name>::to_glib_none(self).0 as *mut _,
diff --git a/glib/src/enums.rs b/glib/src/enums.rs
@@ -245,7 +245,7 @@ impl EnumValue {
     /// Convert enum value to a `Value`.
     pub fn to_value(&self, enum_: &EnumClass) -> Value {
         unsafe {
-            let mut v = Value::from_type(enum_.type_());
+            let mut v = Value::from_type_unchecked(enum_.type_());
             gobject_ffi::g_value_set_enum(v.to_glib_none_mut().0, self.0.value);
             v
         }
@@ -761,7 +761,7 @@ impl FlagsValue {
     /// Convert flags value to a `Value`.
     pub fn to_value(&self, flags: &FlagsClass) -> Value {
         unsafe {
-            let mut v = Value::from_type(flags.type_());
+            let mut v = Value::from_type_unchecked(flags.type_());
             gobject_ffi::g_value_set_flags(v.to_glib_none_mut().0, self.0.value);
             v
         }
@@ -814,7 +814,7 @@ impl Eq for FlagsValue {}
 pub struct FlagsBuilder<'a>(&'a FlagsClass, Option<Value>);
 impl<'a> FlagsBuilder<'a> {
     fn new(flags_class: &FlagsClass) -> FlagsBuilder {
-        let value = Value::from_type(flags_class.type_());
+        let value = unsafe { Value::from_type_unchecked(flags_class.type_()) };
         FlagsBuilder(flags_class, Some(value))
     }
 
diff --git a/glib/src/object.rs b/glib/src/object.rs
@@ -1070,7 +1070,7 @@ macro_rules! glib_object_wrapper {
             #[inline]
             fn to_value(&self) -> $crate::Value {
                 unsafe {
-                    let mut value = $crate::Value::from_type(<Self as $crate::StaticType>::static_type());
+                    let mut value = $crate::Value::from_type_unchecked(<Self as $crate::StaticType>::static_type());
                     $crate::gobject_ffi::g_value_take_object(
                         $crate::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         $crate::translate::ToGlibPtr::<*mut $ffi_name>::to_glib_full(self) as *mut _,
@@ -1090,7 +1090,7 @@ macro_rules! glib_object_wrapper {
             #[inline]
             fn from(o: $name $(<$($generic),+>)?) -> Self {
                 unsafe {
-                    let mut value = $crate::Value::from_type(<$name $(<$($generic),+>)? as $crate::StaticType>::static_type());
+                    let mut value = $crate::Value::from_type_unchecked(<$name $(<$($generic),+>)? as $crate::StaticType>::static_type());
                     $crate::gobject_ffi::g_value_take_object(
                         $crate::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         $crate::translate::IntoGlibPtr::<*mut $ffi_name>::into_glib_ptr(o) as *mut _,
@@ -2363,7 +2363,7 @@ impl<T: ObjectType> ObjectExt for T {
         }
 
         unsafe {
-            let mut value = Value::from_type(pspec.value_type());
+            let mut value = Value::from_type_unchecked(pspec.value_type());
             gobject_ffi::g_object_get_property(
                 self.as_object_ref().to_glib_none().0,
                 pspec.name().as_ptr() as *const _,
@@ -2719,7 +2719,7 @@ impl<T: ObjectType> ObjectExt for T {
             validate_signal_arguments(type_, &signal_query, &mut args[1..]);
 
             let mut return_value = if signal_query.return_type() != Type::UNIT {
-                Value::from_type(signal_query.return_type().into())
+                Value::from_type_unchecked(signal_query.return_type().into())
             } else {
                 Value::uninitialized()
             };
@@ -2766,7 +2766,7 @@ impl<T: ObjectType> ObjectExt for T {
             validate_signal_arguments(type_, &signal_query, &mut args[1..]);
 
             let mut return_value = if signal_query.return_type() != Type::UNIT {
-                Value::from_type(signal_query.return_type().into())
+                Value::from_type_unchecked(signal_query.return_type().into())
             } else {
                 Value::uninitialized()
             };
@@ -2867,7 +2867,7 @@ impl<T: ObjectType> ObjectExt for T {
             validate_signal_arguments(type_, &signal_query, &mut args[1..]);
 
             let mut return_value = if signal_query.return_type() != Type::UNIT {
-                Value::from_type(signal_query.return_type().into())
+                Value::from_type_unchecked(signal_query.return_type().into())
             } else {
                 Value::uninitialized()
             };
@@ -2920,7 +2920,7 @@ impl<T: ObjectType> ObjectExt for T {
             validate_signal_arguments(type_, &signal_query, &mut args[1..]);
 
             let mut return_value = if signal_query.return_type() != Type::UNIT {
-                Value::from_type(signal_query.return_type().into())
+                Value::from_type_unchecked(signal_query.return_type().into())
             } else {
                 Value::uninitialized()
             };
diff --git a/glib/src/param_spec.rs b/glib/src/param_spec.rs
@@ -69,7 +69,7 @@ unsafe impl<'a> crate::value::FromValue<'a> for &'a ParamSpec {
 impl crate::value::ToValue for ParamSpec {
     fn to_value(&self) -> crate::Value {
         unsafe {
-            let mut value = crate::Value::from_type(ParamSpec::static_type());
+            let mut value = crate::Value::from_type_unchecked(ParamSpec::static_type());
             gobject_ffi::g_value_take_param(value.to_glib_none_mut().0, self.to_glib_full());
             value
         }
@@ -85,7 +85,7 @@ impl From<ParamSpec> for crate::Value {
     #[inline]
     fn from(s: ParamSpec) -> Self {
         unsafe {
-            let mut value = crate::Value::from_type(ParamSpec::static_type());
+            let mut value = crate::Value::from_type_unchecked(ParamSpec::static_type());
             gobject_ffi::g_value_take_param(value.to_glib_none_mut().0, s.into_glib_ptr());
             value
         }
@@ -349,7 +349,7 @@ macro_rules! define_param_spec {
         impl crate::value::ToValue for $rust_type {
             fn to_value(&self) -> crate::Value {
                 unsafe {
-                    let mut value = crate::Value::from_type($rust_type::static_type());
+                    let mut value = crate::Value::from_type_unchecked($rust_type::static_type());
                     gobject_ffi::g_value_take_param(value.to_glib_none_mut().0, $crate::translate::ToGlibPtr::<*const $ffi_type>::to_glib_full(self) as *mut _);
                     value
                 }
@@ -365,7 +365,7 @@ macro_rules! define_param_spec {
             #[inline]
             fn from(s: $rust_type) -> Self {
                 unsafe {
-                    let mut value = crate::Value::from_type($rust_type::static_type());
+                    let mut value = crate::Value::from_type_unchecked($rust_type::static_type());
                     gobject_ffi::g_value_take_param(
                         value.to_glib_none_mut().0,
                         $crate::translate::IntoGlibPtr::<*mut gobject_ffi::GParamSpec>::into_glib_ptr(s),
diff --git a/glib/src/shared.rs b/glib/src/shared.rs
@@ -379,7 +379,7 @@ macro_rules! glib_shared_wrapper {
             #[inline]
             fn to_value(&self) -> $crate::Value {
                 unsafe {
-                    let mut value = $crate::Value::from_type(<Self as $crate::StaticType>::static_type());
+                    let mut value = $crate::Value::from_type_unchecked(<Self as $crate::StaticType>::static_type());
                     $crate::gobject_ffi::g_value_take_boxed(
                         $crate::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         $crate::translate::ToGlibPtr::<*mut $ffi_name>::to_glib_full(self) as *mut _,
@@ -398,7 +398,7 @@ macro_rules! glib_shared_wrapper {
             #[inline]
             fn from(s: $name $(<$($generic),+>)?) -> Self {
                 unsafe {
-                    let mut value = $crate::Value::from_type(<$name $(<$($generic),+>)? as $crate::StaticType>::static_type());
+                    let mut value = $crate::Value::from_type_unchecked(<$name $(<$($generic),+>)? as $crate::StaticType>::static_type());
                     $crate::gobject_ffi::g_value_take_boxed(
                         $crate::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
                         $crate::translate::IntoGlibPtr::<*mut $ffi_name>::into_glib_ptr(s) as *mut _,
diff --git a/glib/src/subclass/types.rs b/glib/src/subclass/types.rs
@@ -1081,7 +1081,7 @@ pub(crate) unsafe fn signal_chain_from_overridden(
         "Arguments must be forwarded without changes when chaining up"
     );
 
-    let mut result = Value::from_type(token.1);
+    let mut result = Value::from_type_unchecked(token.1);
     gobject_ffi::g_signal_chain_from_overridden(
         values.as_ptr() as *mut Value as *mut gobject_ffi::GValue,
         result.to_glib_none_mut().0,
diff --git a/glib/src/types.rs b/glib/src/types.rs
@@ -283,7 +283,7 @@ impl crate::value::ToValue for Type {
     #[inline]
     fn to_value(&self) -> crate::Value {
         unsafe {
-            let mut value = crate::Value::from_type(Type::static_type());
+            let mut value = crate::Value::from_type_unchecked(Type::static_type());
             gobject_ffi::g_value_set_gtype(value.to_glib_none_mut().0, self.into_glib());
             value
         }
diff --git a/glib/src/value.rs b/glib/src/value.rs
@@ -491,14 +491,30 @@ crate::wrapper! {
 
 impl Value {
     // rustdoc-stripper-ignore-next
-    /// Creates a new `Value` that is initialized with `type_`
-    #[inline]
+    /// Creates a new `Value` that is initialized with `type_`.
+    ///
+    /// # Panics
+    ///
+    /// If `type_` can't be stored in a `Value` this function panics.
     pub fn from_type(type_: Type) -> Self {
         unsafe {
             assert_eq!(
                 gobject_ffi::g_type_check_is_value_type(type_.into_glib()),
                 ffi::GTRUE
             );
+            Self::from_type_unchecked(type_)
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Creates a new `Value` that is initialized with `type_`.
+    ///
+    /// # SAFETY
+    ///
+    /// This must be called with a valid `type_` that can be stored in `Value`s.
+    #[inline]
+    pub unsafe fn from_type_unchecked(type_: Type) -> Self {
+        unsafe {
             let mut value = Value::uninitialized();
             gobject_ffi::g_value_init(value.to_glib_none_mut().0, type_.into_glib());
             value
@@ -509,7 +525,7 @@ impl Value {
     /// Creates a new `Value` that is initialized for a given `ValueType`.
     #[inline]
     pub fn for_value_type<T: ValueType>() -> Self {
-        Value::from_type(T::Type::static_type())
+        unsafe { Value::from_type_unchecked(T::Type::static_type()) }
     }
 
     // rustdoc-stripper-ignore-next
@@ -817,7 +833,7 @@ unsafe impl<'a> FromValue<'a> for &'a str {
 impl ToValue for str {
     fn to_value(&self) -> Value {
         unsafe {
-            let mut value = Value::from_type(<String>::static_type());
+            let mut value = Value::for_value_type::<String>();
 
             gobject_ffi::g_value_take_string(value.to_glib_none_mut().0, self.to_glib_full());
 
@@ -1226,7 +1242,7 @@ impl ToValue for BoxedValue {
     #[inline]
     fn to_value(&self) -> Value {
         unsafe {
-            let mut value = Value::from_type(<BoxedValue>::static_type());
+            let mut value = Value::for_value_type::<BoxedValue>();
 
             gobject_ffi::g_value_set_boxed(
                 value.to_glib_none_mut().0,
@@ -1247,7 +1263,7 @@ impl From<BoxedValue> for Value {
     #[inline]
     fn from(v: BoxedValue) -> Self {
         unsafe {
-            let mut value = Value::from_type(<BoxedValue>::static_type());
+            let mut value = Value::for_value_type::<BoxedValue>();
 
             gobject_ffi::g_value_take_boxed(
                 value.to_glib_none_mut().0,
diff --git a/glib/src/variant.rs b/glib/src/variant.rs
@@ -158,7 +158,7 @@ unsafe impl<'a> crate::value::FromValue<'a> for Variant {
 impl crate::value::ToValue for Variant {
     fn to_value(&self) -> crate::Value {
         unsafe {
-            let mut value = crate::Value::from_type(Variant::static_type());
+            let mut value = crate::Value::from_type_unchecked(Variant::static_type());
             gobject_ffi::g_value_take_variant(value.to_glib_none_mut().0, self.to_glib_full());
             value
         }
@@ -174,7 +174,7 @@ impl From<Variant> for crate::Value {
     #[inline]
     fn from(v: Variant) -> Self {
         unsafe {
-            let mut value = crate::Value::from_type(Variant::static_type());
+            let mut value = crate::Value::from_type_unchecked(Variant::static_type());
             gobject_ffi::g_value_take_variant(value.to_glib_none_mut().0, v.into_glib_ptr());
             value
         }
diff --git a/glib/src/variant_type.rs b/glib/src/variant_type.rs

Original file line number	Diff line number	Diff line change
`@@ -245,7 +245,7 @@ impl EnumValue {`
`245`	`245`	/// Convert enum value to a `Value`.
`246`	`246`	`pub fn to_value(&self, enum_: &EnumClass) -> Value {`
`247`	`247`	`unsafe {`
`248`		`- let mut v = Value::from_type(enum_.type_());`
	`248`	`+ let mut v = Value::from_type_unchecked(enum_.type_());`
`249`	`249`	`gobject_ffi::g_value_set_enum(v.to_glib_none_mut().0, self.0.value);`
`250`	`250`	`v`
`251`	`251`	`}`
`@@ -761,7 +761,7 @@ impl FlagsValue {`
`761`	`761`	/// Convert flags value to a `Value`.
`762`	`762`	`pub fn to_value(&self, flags: &FlagsClass) -> Value {`
`763`	`763`	`unsafe {`
`764`		`- let mut v = Value::from_type(flags.type_());`
	`764`	`+ let mut v = Value::from_type_unchecked(flags.type_());`
`765`	`765`	`gobject_ffi::g_value_set_flags(v.to_glib_none_mut().0, self.0.value);`
`766`	`766`	`v`
`767`	`767`	`}`
`@@ -814,7 +814,7 @@ impl Eq for FlagsValue {}`
`814`	`814`	`pub struct FlagsBuilder<'a>(&'a FlagsClass, Option<Value>);`
`815`	`815`	`impl<'a> FlagsBuilder<'a> {`
`816`	`816`	`fn new(flags_class: &FlagsClass) -> FlagsBuilder {`
`817`		`- let value = Value::from_type(flags_class.type_());`
	`817`	`+ let value = unsafe { Value::from_type_unchecked(flags_class.type_()) };`
`818`	`818`	`FlagsBuilder(flags_class, Some(value))`
`819`	`819`	`}`
`820`	`820`