glib: use Into<Value> instead of ToValue when possible

Author: jf2048

glib-macros/src/closure.rs

@@ -255,8 +255,8 @@ impl ToTokens for Closure {
                         );
                         #(#inner_before)*
                         #(#arg_values)*
-                        #crate_ident::closure::ToClosureReturnValue::to_closure_return_value(
-                            &(#closure)(#(#arg_names),*)
+                        #crate_ident::closure::IntoClosureReturnValue::into_closure_return_value(
+                            (#closure)(#(#arg_names),*)
                         )
                     })
                 };

glib/src/closure.rs

@@ -340,19 +340,20 @@ impl Closure {
     }
 }
 
-pub trait ToClosureReturnValue {
-    fn to_closure_return_value(&self) -> Option<Value>;
+pub trait IntoClosureReturnValue {
+    fn into_closure_return_value(self) -> Option<Value>;
 }
 
-impl ToClosureReturnValue for () {
-    fn to_closure_return_value(&self) -> Option<Value> {
+impl IntoClosureReturnValue for () {
+    fn into_closure_return_value(self) -> Option<Value> {
         None
     }
 }
 
-impl<T: ToValue> ToClosureReturnValue for T {
-    fn to_closure_return_value(&self) -> Option<Value> {
-        Some(self.to_value())
+impl<T: Into<Value>> IntoClosureReturnValue for T {
+    #[inline]
+    fn into_closure_return_value(self) -> Option<Value> {
+        Some(self.into())
     }
 }
 

glib/src/gobject/signal_group.rs

@@ -187,15 +187,15 @@ mod tests {
         group.connect_closure(
             "sig-with-ret",
             false,
-            glib::closure_local!(@watch obj => move |o: &SignalObject| -> String {
+            glib::closure_local!(@watch obj => move |o: &SignalObject| -> &'static crate::GStr {
                 assert_eq!(o, obj);
-                format!("Hello")
+                crate::gstr!("Hello")
             }),
         );
         group.set_target(Some(&obj));
         obj.emit_by_name::<()>("sig-with-args", &[&5u32, &"World"]);
         assert_eq!(*store.borrow(), "a 5 b World");
-        let ret = obj.emit_by_name::<String>("sig-with-ret", &[]);
+        let ret = obj.emit_by_name::<crate::GString>("sig-with-ret", &[]);
         assert_eq!(ret, "Hello");
         group.set_target(Object::NONE);
         let ret = obj.emit_by_name::<Option<String>>("sig-with-ret", &[]);

glib/src/object.rs

@@ -1608,13 +1608,13 @@ impl<'a, O: IsA<Object> + IsClass> ObjectBuilder<'a, O> {
 
     // rustdoc-stripper-ignore-next
     /// Set property `name` to the given value `value`.
-    pub fn property<T: ToValue + 'a>(self, name: &'a str, value: T) -> Self {
+    pub fn property(self, name: &'a str, value: impl Into<Value>) -> Self {
         let ObjectBuilder {
             type_,
             mut properties,
             ..
         } = self;
-        properties.push((name, value.to_value()));
+        properties.push((name, value.into()));
 
         ObjectBuilder {
             type_,
@@ -1692,7 +1692,7 @@ pub trait ObjectExt: ObjectType {
     /// If the property does not exist, if the type of the property is different than
     /// the provided value, or if the property is not writable.
     #[doc(alias = "g_object_set_property")]
-    fn set_property<V: ToValue>(&self, property_name: &str, value: V);
+    fn set_property(&self, property_name: &str, value: impl Into<Value>);
 
     // rustdoc-stripper-ignore-next
     /// Sets the property `property_name` of the object to value `value`.
@@ -2298,15 +2298,15 @@ impl<T: ObjectType> ObjectExt for T {
     }
 
     #[track_caller]
-    fn set_property<V: ToValue>(&self, property_name: &str, value: V) {
+    fn set_property(&self, property_name: &str, value: impl Into<Value>) {
         let pspec = self.find_property(property_name).unwrap_or_else(|| {
             panic!(
                 "property '{property_name}' of type '{}' not found",
                 self.type_()
             )
         });
 
-        let mut property_value = value.to_value();
+        let mut property_value = value.into();
         validate_property_type(self.type_(), false, &pspec, &mut property_value);
         unsafe {
             gobject_ffi::g_object_set_property(
@@ -3642,7 +3642,7 @@ impl<'a, 'f, 't> BindingBuilder<'a, 'f, 't> {
     /// See [`Self::transform_from_with_values`] for a version which operates on `glib::Value`s.
     pub fn transform_from<
         S: FromValue<'f>,
-        T: ToValue,
+        T: Into<Value>,
         F: Fn(&'f crate::Binding, S) -> Option<T> + Send + Sync + 'static,
     >(
         self,
@@ -3651,7 +3651,7 @@ impl<'a, 'f, 't> BindingBuilder<'a, 'f, 't> {
         Self {
             transform_from: Some(Box::new(move |binding, from_value| {
                 let from_value = from_value.get().expect("Wrong value type");
-                func(binding, from_value).map(|r| r.to_value())
+                func(binding, from_value).map(|r| r.into())
             })),
             ..self
         }
@@ -3681,7 +3681,7 @@ impl<'a, 'f, 't> BindingBuilder<'a, 'f, 't> {
     /// See [`Self::transform_to_with_values`] for a version which operates on `glib::Value`s.
     pub fn transform_to<
         S: FromValue<'t>,
-        T: ToValue,
+        T: Into<Value>,
         F: Fn(&'t crate::Binding, S) -> Option<T> + Send + Sync + 'static,
     >(
         self,
@@ -3690,7 +3690,7 @@ impl<'a, 'f, 't> BindingBuilder<'a, 'f, 't> {
         Self {
             transform_to: Some(Box::new(move |binding, from_value| {
                 let from_value = from_value.get().expect("Wrong value type");
-                func(binding, from_value).map(|r| r.to_value())
+                func(binding, from_value).map(|r| r.into())
             })),
             ..self
         }