wayland-server: inline a few more common functions

cmeissl · ids1024 · commit c1a626944676 · 2024-05-13T17:08:52.000-07:00
these have shown up in a lot of traces in smithay
diff --git a/wayland-backend/src/server_api.rs b/wayland-backend/src/server_api.rs
@@ -249,13 +249,15 @@ impl WeakHandle {
     /// Try to upgrade this weak handle to a [`Handle`]
     ///
     /// Returns `None` if the associated backend was already dropped.
+    #[inline]
     pub fn upgrade(&self) -> Option<Handle> {
         self.handle.upgrade().map(|handle| Handle { handle })
     }
 }
 
 impl Handle {
     /// Get a [`WeakHandle`] from this handle
+    #[inline]
     pub fn downgrade(&self) -> WeakHandle {
         WeakHandle { handle: self.handle.downgrade() }
     }
diff --git a/wayland-scanner/src/server_gen.rs b/wayland-scanner/src/server_gen.rs
@@ -83,6 +83,7 @@ fn generate_objects_for(interface: &Interface) -> TokenStream {
             }
 
             impl std::cmp::PartialEq for #iface_name {
+                #[inline]
                 fn eq(&self, other: &#iface_name) -> bool {
                     self.id == other.id
                 }
@@ -91,18 +92,21 @@ fn generate_objects_for(interface: &Interface) -> TokenStream {
             impl std::cmp::Eq for #iface_name {}
 
             impl PartialEq<Weak<#iface_name>> for #iface_name {
+                #[inline]
                 fn eq(&self, other: &Weak<#iface_name>) -> bool {
                     self.id == other.id()
                 }
             }
 
             impl std::borrow::Borrow<ObjectId> for #iface_name {
+                #[inline]
                 fn borrow(&self) -> &ObjectId {
                     &self.id
                 }
             }
 
             impl std::hash::Hash for #iface_name {
+                #[inline]
                 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
                     self.id.hash(state)
                 }
diff --git a/wayland-scanner/tests/scanner_assets/test-server-code.rs b/wayland-scanner/tests/scanner_assets/test-server-code.rs
@@ -54,22 +54,26 @@ pub mod wl_callback {
         handle: WeakHandle,
     }
     impl std::cmp::PartialEq for WlCallback {
+        #[inline]
         fn eq(&self, other: &WlCallback) -> bool {
             self.id == other.id
         }
     }
     impl std::cmp::Eq for WlCallback {}
     impl PartialEq<Weak<WlCallback>> for WlCallback {
+        #[inline]
         fn eq(&self, other: &Weak<WlCallback>) -> bool {
             self.id == other.id()
         }
     }
     impl std::borrow::Borrow<ObjectId> for WlCallback {
+        #[inline]
         fn borrow(&self) -> &ObjectId {
             &self.id
         }
     }
     impl std::hash::Hash for WlCallback {
+        #[inline]
         fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
             self.id.hash(state)
         }
@@ -316,22 +320,26 @@ pub mod test_global {
         handle: WeakHandle,
     }
     impl std::cmp::PartialEq for TestGlobal {
+        #[inline]
         fn eq(&self, other: &TestGlobal) -> bool {
             self.id == other.id
         }
     }
     impl std::cmp::Eq for TestGlobal {}
     impl PartialEq<Weak<TestGlobal>> for TestGlobal {
+        #[inline]
         fn eq(&self, other: &Weak<TestGlobal>) -> bool {
             self.id == other.id()
         }
     }
     impl std::borrow::Borrow<ObjectId> for TestGlobal {
+        #[inline]
         fn borrow(&self) -> &ObjectId {
             &self.id
         }
     }
     impl std::hash::Hash for TestGlobal {
+        #[inline]
         fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
             self.id.hash(state)
         }
@@ -822,22 +830,26 @@ pub mod secondary {
         handle: WeakHandle,
     }
     impl std::cmp::PartialEq for Secondary {
+        #[inline]
         fn eq(&self, other: &Secondary) -> bool {
             self.id == other.id
         }
     }
     impl std::cmp::Eq for Secondary {}
     impl PartialEq<Weak<Secondary>> for Secondary {
+        #[inline]
         fn eq(&self, other: &Weak<Secondary>) -> bool {
             self.id == other.id()
         }
     }
     impl std::borrow::Borrow<ObjectId> for Secondary {
+        #[inline]
         fn borrow(&self) -> &ObjectId {
             &self.id
         }
     }
     impl std::hash::Hash for Secondary {
+        #[inline]
         fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
             self.id.hash(state)
         }
@@ -981,22 +993,26 @@ pub mod tertiary {
         handle: WeakHandle,
     }
     impl std::cmp::PartialEq for Tertiary {
+        #[inline]
         fn eq(&self, other: &Tertiary) -> bool {
             self.id == other.id
         }
     }
     impl std::cmp::Eq for Tertiary {}
     impl PartialEq<Weak<Tertiary>> for Tertiary {
+        #[inline]
         fn eq(&self, other: &Weak<Tertiary>) -> bool {
             self.id == other.id()
         }
     }
     impl std::borrow::Borrow<ObjectId> for Tertiary {
+        #[inline]
         fn borrow(&self) -> &ObjectId {
             &self.id
         }
     }
     impl std::hash::Hash for Tertiary {
+        #[inline]
         fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
             self.id.hash(state)
         }
@@ -1140,22 +1156,26 @@ pub mod quad {
         handle: WeakHandle,
     }
     impl std::cmp::PartialEq for Quad {
+        #[inline]
         fn eq(&self, other: &Quad) -> bool {
             self.id == other.id
         }
     }
     impl std::cmp::Eq for Quad {}
     impl PartialEq<Weak<Quad>> for Quad {
+        #[inline]
         fn eq(&self, other: &Weak<Quad>) -> bool {
             self.id == other.id()
         }
     }
     impl std::borrow::Borrow<ObjectId> for Quad {
+        #[inline]
         fn borrow(&self) -> &ObjectId {
             &self.id
         }
     }
     impl std::hash::Hash for Quad {
+        #[inline]
         fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
             self.id.hash(state)
         }
diff --git a/wayland-server/src/lib.rs b/wayland-server/src/lib.rs
@@ -160,6 +160,7 @@ pub trait Resource: Clone + std::fmt::Debug + Sized {
     fn version(&self) -> u32;
 
     /// Checks if the Wayland object associated with this proxy is still alive
+    #[inline]
     fn is_alive(&self) -> bool {
         if let Some(handle) = self.handle().upgrade() {
             handle.object_info(self.id()).is_ok()
@@ -231,6 +232,7 @@ pub trait Resource: Clone + std::fmt::Debug + Sized {
     ///
     /// This can be of use if you need to store resources in the used data of other objects and want
     /// to be sure to avoid reference cycles that would cause memory leaks.
+    #[inline]
     fn downgrade(&self) -> Weak<Self> {
         Weak { handle: self.handle().clone(), id: self.id(), _iface: std::marker::PhantomData }
     }
@@ -285,6 +287,7 @@ impl<I: Resource> Weak<I> {
     /// This will fail if either:
     /// - the object represented by this handle has already been destroyed at the protocol level
     /// - the Wayland connection has already been closed
+    #[inline]
     pub fn upgrade(&self) -> Result<I, InvalidId> {
         let handle = self.handle.upgrade().ok_or(InvalidId)?;
         // Check if the object has been destroyed
@@ -313,6 +316,7 @@ impl<I: Resource> Weak<I> {
 }
 
 impl<I> PartialEq for Weak<I> {
+    #[inline]
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
@@ -321,12 +325,14 @@ impl<I> PartialEq for Weak<I> {
 impl<I> Eq for Weak<I> {}
 
 impl<I> Hash for Weak<I> {
+    #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.id.hash(state);
     }
 }
 
 impl<I: Resource> PartialEq<I> for Weak<I> {
+    #[inline]
     fn eq(&self, other: &I) -> bool {
         self.id == other.id()
     }

Original file line number	Diff line number	Diff line change
`@@ -249,13 +249,15 @@ impl WeakHandle {`
`249`	`249`	/// Try to upgrade this weak handle to a [`Handle`]
`250`	`250`	`///`
`251`	`251`	/// Returns `None` if the associated backend was already dropped.
	`252`	`+ #[inline]`
`252`	`253`	`pub fn upgrade(&self) -> Option<Handle> {`
`253`	`254`	`self.handle.upgrade().map(\|handle\| Handle { handle })`
`254`	`255`	`}`
`255`	`256`	`}`
`256`	`257`
`257`	`258`	`impl Handle {`
`258`	`259`	/// Get a [`WeakHandle`] from this handle
	`260`	`+ #[inline]`
`259`	`261`	`pub fn downgrade(&self) -> WeakHandle {`
`260`	`262`	`WeakHandle { handle: self.handle.downgrade() }`
`261`	`263`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,7 @@ fn generate_objects_for(interface: &Interface) -> TokenStream {`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`impl std::cmp::PartialEq for #iface_name {`
	`86`	`+ #[inline]`
`86`	`87`	`fn eq(&self, other: &#iface_name) -> bool {`
`87`	`88`	`self.id == other.id`
`88`	`89`	`}`
`@@ -91,18 +92,21 @@ fn generate_objects_for(interface: &Interface) -> TokenStream {`
`91`	`92`	`impl std::cmp::Eq for #iface_name {}`
`92`	`93`
`93`	`94`	`impl PartialEq<Weak<#iface_name>> for #iface_name {`
	`95`	`+ #[inline]`
`94`	`96`	`fn eq(&self, other: &Weak<#iface_name>) -> bool {`
`95`	`97`	`self.id == other.id()`
`96`	`98`	`}`
`97`	`99`	`}`
`98`	`100`
`99`	`101`	`impl std::borrow::Borrow<ObjectId> for #iface_name {`
	`102`	`+ #[inline]`
`100`	`103`	`fn borrow(&self) -> &ObjectId {`
`101`	`104`	`&self.id`
`102`	`105`	`}`
`103`	`106`	`}`
`104`	`107`
`105`	`108`	`impl std::hash::Hash for #iface_name {`
	`109`	`+ #[inline]`
`106`	`110`	`fn hash<H: std::hash::Hasher>(&self, state: &mut H) {`
`107`	`111`	`self.id.hash(state)`
`108`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,22 +54,26 @@ pub mod wl_callback {`
`54`	`54`	`handle: WeakHandle,`
`55`	`55`	`}`
`56`	`56`	`impl std::cmp::PartialEq for WlCallback {`
	`57`	`+ #[inline]`
`57`	`58`	`fn eq(&self, other: &WlCallback) -> bool {`
`58`	`59`	`self.id == other.id`
`59`	`60`	`}`
`60`	`61`	`}`
`61`	`62`	`impl std::cmp::Eq for WlCallback {}`
`62`	`63`	`impl PartialEq<Weak<WlCallback>> for WlCallback {`
	`64`	`+ #[inline]`
`63`	`65`	`fn eq(&self, other: &Weak<WlCallback>) -> bool {`
`64`	`66`	`self.id == other.id()`
`65`	`67`	`}`
`66`	`68`	`}`
`67`	`69`	`impl std::borrow::Borrow<ObjectId> for WlCallback {`
	`70`	`+ #[inline]`
`68`	`71`	`fn borrow(&self) -> &ObjectId {`
`69`	`72`	`&self.id`
`70`	`73`	`}`
`71`	`74`	`}`
`72`	`75`	`impl std::hash::Hash for WlCallback {`
	`76`	`+ #[inline]`
`73`	`77`	`fn hash<H: std::hash::Hasher>(&self, state: &mut H) {`
`74`	`78`	`self.id.hash(state)`
`75`	`79`	`}`
`@@ -316,22 +320,26 @@ pub mod test_global {`
`316`	`320`	`handle: WeakHandle,`
`317`	`321`	`}`
`318`	`322`	`impl std::cmp::PartialEq for TestGlobal {`
	`323`	`+ #[inline]`
`319`	`324`	`fn eq(&self, other: &TestGlobal) -> bool {`
`320`	`325`	`self.id == other.id`
`321`	`326`	`}`
`322`	`327`	`}`
`323`	`328`	`impl std::cmp::Eq for TestGlobal {}`
`324`	`329`	`impl PartialEq<Weak<TestGlobal>> for TestGlobal {`
	`330`	`+ #[inline]`
`325`	`331`	`fn eq(&self, other: &Weak<TestGlobal>) -> bool {`
`326`	`332`	`self.id == other.id()`
`327`	`333`	`}`
`328`	`334`	`}`
`329`	`335`	`impl std::borrow::Borrow<ObjectId> for TestGlobal {`
	`336`	`+ #[inline]`
`330`	`337`	`fn borrow(&self) -> &ObjectId {`
`331`	`338`	`&self.id`
`332`	`339`	`}`
`333`	`340`	`}`
`334`	`341`	`impl std::hash::Hash for TestGlobal {`
	`342`	`+ #[inline]`
`335`	`343`	`fn hash<H: std::hash::Hasher>(&self, state: &mut H) {`
`336`	`344`	`self.id.hash(state)`
`337`	`345`	`}`
`@@ -822,22 +830,26 @@ pub mod secondary {`
`822`	`830`	`handle: WeakHandle,`
`823`	`831`	`}`
`824`	`832`	`impl std::cmp::PartialEq for Secondary {`
	`833`	`+ #[inline]`
`825`	`834`	`fn eq(&self, other: &Secondary) -> bool {`
`826`	`835`	`self.id == other.id`
`827`	`836`	`}`
`828`	`837`	`}`
`829`	`838`	`impl std::cmp::Eq for Secondary {}`
`830`	`839`	`impl PartialEq<Weak<Secondary>> for Secondary {`
	`840`	`+ #[inline]`
`831`	`841`	`fn eq(&self, other: &Weak<Secondary>) -> bool {`
`832`	`842`	`self.id == other.id()`
`833`	`843`	`}`
`834`	`844`	`}`
`835`	`845`	`impl std::borrow::Borrow<ObjectId> for Secondary {`
	`846`	`+ #[inline]`
`836`	`847`	`fn borrow(&self) -> &ObjectId {`
`837`	`848`	`&self.id`
`838`	`849`	`}`
`839`	`850`	`}`
`840`	`851`	`impl std::hash::Hash for Secondary {`
	`852`	`+ #[inline]`
`841`	`853`	`fn hash<H: std::hash::Hasher>(&self, state: &mut H) {`
`842`	`854`	`self.id.hash(state)`
`843`	`855`	`}`
`@@ -981,22 +993,26 @@ pub mod tertiary {`
`981`	`993`	`handle: WeakHandle,`
`982`	`994`	`}`
`983`	`995`	`impl std::cmp::PartialEq for Tertiary {`
	`996`	`+ #[inline]`
`984`	`997`	`fn eq(&self, other: &Tertiary) -> bool {`
`985`	`998`	`self.id == other.id`
`986`	`999`	`}`
`987`	`1000`	`}`
`988`	`1001`	`impl std::cmp::Eq for Tertiary {}`
`989`	`1002`	`impl PartialEq<Weak<Tertiary>> for Tertiary {`
	`1003`	`+ #[inline]`
`990`	`1004`	`fn eq(&self, other: &Weak<Tertiary>) -> bool {`
`991`	`1005`	`self.id == other.id()`
`992`	`1006`	`}`
`993`	`1007`	`}`
`994`	`1008`	`impl std::borrow::Borrow<ObjectId> for Tertiary {`
	`1009`	`+ #[inline]`
`995`	`1010`	`fn borrow(&self) -> &ObjectId {`
`996`	`1011`	`&self.id`
`997`	`1012`	`}`
`998`	`1013`	`}`
`999`	`1014`	`impl std::hash::Hash for Tertiary {`
	`1015`	`+ #[inline]`
`1000`	`1016`	`fn hash<H: std::hash::Hasher>(&self, state: &mut H) {`
`1001`	`1017`	`self.id.hash(state)`
`1002`	`1018`	`}`
`@@ -1140,22 +1156,26 @@ pub mod quad {`
`1140`	`1156`	`handle: WeakHandle,`
`1141`	`1157`	`}`
`1142`	`1158`	`impl std::cmp::PartialEq for Quad {`
	`1159`	`+ #[inline]`
`1143`	`1160`	`fn eq(&self, other: &Quad) -> bool {`
`1144`	`1161`	`self.id == other.id`
`1145`	`1162`	`}`
`1146`	`1163`	`}`
`1147`	`1164`	`impl std::cmp::Eq for Quad {}`
`1148`	`1165`	`impl PartialEq<Weak<Quad>> for Quad {`
	`1166`	`+ #[inline]`
`1149`	`1167`	`fn eq(&self, other: &Weak<Quad>) -> bool {`
`1150`	`1168`	`self.id == other.id()`
`1151`	`1169`	`}`
`1152`	`1170`	`}`
`1153`	`1171`	`impl std::borrow::Borrow<ObjectId> for Quad {`
	`1172`	`+ #[inline]`
`1154`	`1173`	`fn borrow(&self) -> &ObjectId {`
`1155`	`1174`	`&self.id`
`1156`	`1175`	`}`
`1157`	`1176`	`}`
`1158`	`1177`	`impl std::hash::Hash for Quad {`
	`1178`	`+ #[inline]`
`1159`	`1179`	`fn hash<H: std::hash::Hasher>(&self, state: &mut H) {`
`1160`	`1180`	`self.id.hash(state)`
`1161`	`1181`	`}`