chore: Fix errors of clippy beta

kjarosh · torokati44 · commit 36079912c256 · 2025-04-07T19:02:22.000+02:00
Fix the following additional checks:
1. use std::ptr::eq to compare pointers,
2. use IoError::other.
diff --git a/core/src/avm1/debug.rs b/core/src/avm1/debug.rs
@@ -40,7 +40,7 @@ impl<'a> VariableDumper<'a> {
         let ptr = object.as_ptr();
 
         for (i, other) in self.objects.iter().enumerate() {
-            if *other == ptr {
+            if std::ptr::eq(*other, ptr) {
                 return (i, false);
             }
         }
diff --git a/core/src/avm1/object.rs b/core/src/avm1/object.rs
@@ -644,7 +644,7 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Into<Object<'gc>> + Clone + Copy {
         let mut proto = other.proto(activation);
 
         while let Value::Object(proto_ob) = proto {
-            if self.as_ptr() == proto_ob.as_ptr() {
+            if std::ptr::eq(self.as_ptr(), proto_ob.as_ptr()) {
                 return true;
             }
 
@@ -699,7 +699,7 @@ pub enum ObjectPtr {}
 
 impl<'gc> Object<'gc> {
     pub fn ptr_eq(a: Object<'gc>, b: Object<'gc>) -> bool {
-        a.as_ptr() == b.as_ptr()
+        std::ptr::eq(a.as_ptr(), b.as_ptr())
     }
 }
 
diff --git a/core/src/avm2.rs b/core/src/avm2.rs
@@ -361,7 +361,7 @@ impl<'gc> Avm2<'gc> {
         if self
             .orphan_objects
             .iter()
-            .all(|d| d.as_ptr() != dobj.as_ptr())
+            .all(|d| !std::ptr::eq(d.as_ptr(), dobj.as_ptr()))
         {
             self.orphan_objects_mut().push(dobj.downgrade());
         }
@@ -493,7 +493,7 @@ impl<'gc> Avm2<'gc> {
         for entry in bucket.iter() {
             // Note: comparing pointers is correct because GcWeak keeps its allocation alive,
             // so the pointers can't overlap by accident.
-            if entry.as_ptr() == object.as_ptr() {
+            if std::ptr::eq(entry.as_ptr(), object.as_ptr()) {
                 return;
             }
         }
diff --git a/core/src/avm2/bytearray.rs b/core/src/avm2/bytearray.rs
@@ -396,9 +396,8 @@ impl ByteArrayStorage {
 
 impl Write for ByteArrayStorage {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.write_bytes(buf).map_err(|_| {
-            io::Error::new(io::ErrorKind::Other, "Failed to write to ByteArrayStorage")
-        })?;
+        self.write_bytes(buf)
+            .map_err(|_| io::Error::other("Failed to write to ByteArrayStorage"))?;
 
         Ok(buf.len())
     }
@@ -412,9 +411,7 @@ impl Read for ByteArrayStorage {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let bytes = self
             .read_bytes(cmp::min(buf.len(), self.bytes_available()))
-            .map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "Failed to read from ByteArrayStorage")
-            })?;
+            .map_err(|_| io::Error::other("Failed to read from ByteArrayStorage"))?;
         buf[..bytes.len()].copy_from_slice(bytes);
         Ok(bytes.len())
     }
diff --git a/core/src/avm2/domain.rs b/core/src/avm2/domain.rs
@@ -93,7 +93,7 @@ impl<'gc> Domain<'gc> {
     }
 
     pub fn is_playerglobals_domain(&self, avm2: &Avm2<'gc>) -> bool {
-        avm2.playerglobals_domain.0.as_ptr() == self.0.as_ptr()
+        std::ptr::eq(avm2.playerglobals_domain.0.as_ptr(), self.0.as_ptr())
     }
 
     pub fn children(&self, mc: &Mutation<'gc>) -> Vec<Domain<'gc>> {
@@ -341,11 +341,12 @@ impl<'gc> Domain<'gc> {
 
     pub fn is_default_domain_memory(&self) -> bool {
         let read = self.0.read();
-        read.domain_memory.expect("Missing domain memory").as_ptr()
-            == read
-                .default_domain_memory
-                .expect("Missing default domain memory")
-                .as_ptr()
+        let domain_memory_ptr = read.domain_memory.expect("Missing domain memory").as_ptr();
+        let default_domain_memory_ptr = read
+            .default_domain_memory
+            .expect("Missing default domain memory")
+            .as_ptr();
+        std::ptr::eq(domain_memory_ptr, default_domain_memory_ptr)
     }
 
     pub fn domain_memory(&self) -> ByteArrayObject<'gc> {
@@ -420,7 +421,7 @@ pub enum DomainPtr {}
 
 impl PartialEq for Domain<'_> {
     fn eq(&self, other: &Self) -> bool {
-        self.0.as_ptr() == other.0.as_ptr()
+        std::ptr::eq(self.0.as_ptr(), other.0.as_ptr())
     }
 }
 
diff --git a/core/src/avm2/filters.rs b/core/src/avm2/filters.rs
@@ -51,7 +51,7 @@ impl ShaderObject for ObjectWrapper {
 
     fn equals(&self, other: &dyn ShaderObject) -> bool {
         if let Some(other_wrapper) = other.downcast_ref::<ObjectWrapper>() {
-            self.root.as_ptr() == other_wrapper.root.as_ptr()
+            std::ptr::eq(self.root.as_ptr(), other_wrapper.root.as_ptr())
         } else {
             false
         }
diff --git a/core/src/avm2/object.rs b/core/src/avm2/object.rs
@@ -916,7 +916,7 @@ pub enum ObjectPtr {}
 
 impl<'gc> Object<'gc> {
     pub fn ptr_eq<T: TObject<'gc>>(a: T, b: T) -> bool {
-        a.as_ptr() == b.as_ptr()
+        std::ptr::eq(a.as_ptr(), b.as_ptr())
     }
 
     #[rustfmt::skip]
diff --git a/core/src/bitmap/bitmap_data.rs b/core/src/bitmap/bitmap_data.rs
@@ -479,7 +479,7 @@ mod wrapper {
             self.0
                 .write(mc)
                 .display_objects
-                .retain(|c| c.as_ptr() != callback.as_ptr())
+                .retain(|c| !std::ptr::eq(c.as_ptr(), callback.as_ptr()))
         }
 
         pub fn add_display_object(&self, mc: &Mutation<'gc>, callback: DisplayObjectWeak<'gc>) {
diff --git a/core/src/buffer.rs b/core/src/buffer.rs
@@ -3,7 +3,7 @@
 use gc_arena::Collect;
 use std::cmp::min;
 use std::fmt::{Debug, Formatter, LowerHex, UpperHex};
-use std::io::{Error as IoError, ErrorKind as IoErrorKind, Read, Result as IoResult};
+use std::io::{Error as IoError, Read, Result as IoResult};
 use std::ops::{Bound, Deref, RangeBounds};
 use std::sync::{Arc, RwLock, RwLockReadGuard};
 use thiserror::Error;
@@ -463,10 +463,7 @@ impl Read for SubstreamCursor {
         let mut out_count = 0;
         let buf_owned = self.substream.buf.clone();
         let buf = buf_owned.0.read().map_err(|_| {
-            IoError::new(
-                IoErrorKind::Other,
-                "the underlying substream is locked by a panicked process",
-            )
+            IoError::other("the underlying substream is locked by a panicked process")
         })?;
 
         let chunks = self.substream.chunks.read().unwrap();
@@ -545,7 +542,7 @@ impl Deref for SliceRef<'_> {
 
 impl PartialEq for SliceRef<'_> {
     fn eq(&self, other: &SliceRef<'_>) -> bool {
-        self.guard.as_ptr() == other.guard.as_ptr()
+        std::ptr::eq(self.guard.as_ptr(), other.guard.as_ptr())
             && self.start == other.start
             && self.end == other.end
     }
diff --git a/core/src/debug_ui/display_object.rs b/core/src/debug_ui/display_object.rs
@@ -972,7 +972,7 @@ impl DisplayObjectWindow {
                 ui.end_row();
 
                 ui.label("AVM1 Root");
-                if object.avm1_root().as_ptr() != object.as_ptr() {
+                if !std::ptr::eq(object.avm1_root().as_ptr(), object.as_ptr()) {
                     open_display_object_button(
                         ui,
                         context,
@@ -987,7 +987,7 @@ impl DisplayObjectWindow {
 
                 ui.label("AVM2 Root");
                 if let Some(other) = object.avm2_root() {
-                    if other.as_ptr() != object.as_ptr() {
+                    if !std::ptr::eq(other.as_ptr(), object.as_ptr()) {
                         open_display_object_button(
                             ui,
                             context,
diff --git a/core/src/debug_ui/handle.rs b/core/src/debug_ui/handle.rs
@@ -48,7 +48,7 @@ impl Debug for DisplayObjectHandle {
 impl PartialEq<DisplayObjectHandle> for DisplayObjectHandle {
     #[inline(always)]
     fn eq(&self, other: &DisplayObjectHandle) -> bool {
-        self.ptr == other.ptr
+        std::ptr::eq(self.ptr, other.ptr)
     }
 }
 
@@ -91,7 +91,7 @@ impl Debug for AVM1ObjectHandle {
 impl PartialEq<AVM1ObjectHandle> for AVM1ObjectHandle {
     #[inline(always)]
     fn eq(&self, other: &AVM1ObjectHandle) -> bool {
-        self.ptr == other.ptr
+        std::ptr::eq(self.ptr, other.ptr)
     }
 }
 
@@ -134,7 +134,7 @@ impl Debug for AVM2ObjectHandle {
 impl PartialEq<AVM2ObjectHandle> for AVM2ObjectHandle {
     #[inline(always)]
     fn eq(&self, other: &AVM2ObjectHandle) -> bool {
-        self.ptr == other.ptr
+        std::ptr::eq(self.ptr, other.ptr)
     }
 }
 
@@ -179,7 +179,7 @@ impl Debug for DomainHandle {
 impl PartialEq<DomainHandle> for DomainHandle {
     #[inline(always)]
     fn eq(&self, other: &DomainHandle) -> bool {
-        self.ptr == other.ptr
+        std::ptr::eq(self.ptr, other.ptr)
     }
 }
 
diff --git a/core/src/display_object.rs b/core/src/display_object.rs
@@ -2557,7 +2557,7 @@ pub enum DisplayObjectPtr {}
 
 impl<'gc> DisplayObject<'gc> {
     pub fn ptr_eq(a: DisplayObject<'gc>, b: DisplayObject<'gc>) -> bool {
-        a.as_ptr() == b.as_ptr()
+        std::ptr::eq(a.as_ptr(), b.as_ptr())
     }
 
     pub fn option_ptr_eq(a: Option<DisplayObject<'gc>>, b: Option<DisplayObject<'gc>>) -> bool {
diff --git a/core/src/display_object/interactive.rs b/core/src/display_object/interactive.rs
@@ -793,7 +793,7 @@ impl<'gc> Avm2MousePick<'gc> {
 
 impl<'gc> InteractiveObject<'gc> {
     pub fn ptr_eq<T: TInteractiveObject<'gc>>(a: T, b: T) -> bool {
-        a.as_displayobject().as_ptr() == b.as_displayobject().as_ptr()
+        std::ptr::eq(a.as_displayobject().as_ptr(), b.as_displayobject().as_ptr())
     }
 
     pub fn option_ptr_eq(
diff --git a/core/src/display_object/loader_display.rs b/core/src/display_object/loader_display.rs
@@ -225,7 +225,7 @@ impl<'gc> TInteractiveObject<'gc> for LoaderDisplay<'gc> {
                         .mouse_pick_avm2(context, point, require_button_mode)
                         .combine_with_parent((*self).into());
                     if let Avm2MousePick::Hit(target) = res {
-                        if target.as_displayobject().as_ptr() == child.as_ptr() {
+                        if std::ptr::eq(target.as_displayobject().as_ptr(), child.as_ptr()) {
                             if self.mouse_enabled() {
                                 return Avm2MousePick::Hit((*self).into());
                             } else {
diff --git a/core/src/streams.rs b/core/src/streams.rs
@@ -153,7 +153,7 @@ pub struct NetStream<'gc>(GcCell<'gc, NetStreamData<'gc>>);
 
 impl PartialEq for NetStream<'_> {
     fn eq(&self, other: &Self) -> bool {
-        self.0.as_ptr() == other.0.as_ptr()
+        std::ptr::eq(self.0.as_ptr(), other.0.as_ptr())
     }
 }
 
diff --git a/core/src/string/repr.rs b/core/src/string/repr.rs
@@ -113,7 +113,7 @@ impl<'gc> AvmStringRepr<'gc> {
             let first_requested = left_ptr.add(char_size * left.len());
 
             let mut chars_available = 0;
-            if first_available == first_requested {
+            if std::ptr::eq(first_available, first_requested) {
                 let left_capacity_end =
                     left_origin_ptr.add(char_size * left_origin.capacity.get().len());
                 chars_available =
diff --git a/render/webgl/src/lib.rs b/render/webgl/src/lib.rs
@@ -947,7 +947,7 @@ impl WebGlRenderBackend {
         // Set common render state, while minimizing unnecessary state changes.
         // TODO: Using designated layout specifiers in WebGL2/OpenGL ES 3, we could guarantee that uniforms
         // are in the same location between shaders, and avoid changing them unless necessary.
-        if program as *const ShaderProgram != self.active_program {
+        if !std::ptr::eq(program, self.active_program) {
             self.gl.use_program(Some(&program.program));
             self.active_program = program as *const ShaderProgram;
 
@@ -1299,7 +1299,7 @@ impl CommandHandler for WebGlRenderBackend {
         // Set common render state, while minimizing unnecessary state changes.
         // TODO: Using designated layout specifiers in WebGL2/OpenGL ES 3, we could guarantee that uniforms
         // are in the same location between shaders, and avoid changing them unless necessary.
-        if program as *const ShaderProgram != self.active_program {
+        if !std::ptr::eq(program, self.active_program) {
             self.gl.use_program(Some(&program.program));
             self.active_program = program as *const ShaderProgram;
 
@@ -1391,7 +1391,7 @@ impl CommandHandler for WebGlRenderBackend {
             // Set common render state, while minimizing unnecessary state changes.
             // TODO: Using designated layout specifiers in WebGL2/OpenGL ES 3, we could guarantee that uniforms
             // are in the same location between shaders, and avoid changing them unless necessary.
-            if program as *const ShaderProgram != self.active_program {
+            if !std::ptr::eq(program, self.active_program) {
                 self.gl.use_program(Some(&program.program));
                 self.active_program = program as *const ShaderProgram;
 
diff --git a/scanner/src/execute.rs b/scanner/src/execute.rs
@@ -44,10 +44,7 @@ fn checkpoint<W: Write>(
     writer.serialize(file_result).unwrap();
 
     if has_error {
-        Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            "Error encountered, test terminated",
-        ))
+        Err(std::io::Error::other("Error encountered, test terminated"))
     } else {
         Ok(())
     }
diff --git a/swf/src/avm1/read.rs b/swf/src/avm1/read.rs
@@ -62,7 +62,7 @@ impl<'a> Reader<'a> {
 
         // Verify that we parsed the correct amount of data.
         let end_pos = (start.as_ptr() as usize + length) as *const u8;
-        if self.input.as_ptr() != end_pos {
+        if !std::ptr::eq(self.input.as_ptr(), end_pos) {
             // We incorrectly parsed this action.
             // Re-sync to the expected end of the action and throw an error.
             self.input = &start[length.min(start.len())..];

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ impl<'a> VariableDumper<'a> {`
`40`	`40`	`let ptr = object.as_ptr();`
`41`	`41`
`42`	`42`	`for (i, other) in self.objects.iter().enumerate() {`
`43`		`- if *other == ptr {`
	`43`	`+ if std::ptr::eq(*other, ptr) {`
`44`	`44`	`return (i, false);`
`45`	`45`	`}`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -644,7 +644,7 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Into<Object<'gc>> + Clone + Copy {`
`644`	`644`	`let mut proto = other.proto(activation);`
`645`	`645`
`646`	`646`	`while let Value::Object(proto_ob) = proto {`
`647`		`- if self.as_ptr() == proto_ob.as_ptr() {`
	`647`	`+ if std::ptr::eq(self.as_ptr(), proto_ob.as_ptr()) {`
`648`	`648`	`return true;`
`649`	`649`	`}`
`650`	`650`
`@@ -699,7 +699,7 @@ pub enum ObjectPtr {}`
`699`	`699`
`700`	`700`	`impl<'gc> Object<'gc> {`
`701`	`701`	`pub fn ptr_eq(a: Object<'gc>, b: Object<'gc>) -> bool {`
`702`		`- a.as_ptr() == b.as_ptr()`
	`702`	`+ std::ptr::eq(a.as_ptr(), b.as_ptr())`
`703`	`703`	`}`
`704`	`704`	`}`
`705`	`705`
Original file line number	Diff line number	Diff line change
`@@ -361,7 +361,7 @@ impl<'gc> Avm2<'gc> {`
`361`	`361`	`if self`
`362`	`362`	`.orphan_objects`
`363`	`363`	`.iter()`
`364`		`- .all(\|d\| d.as_ptr() != dobj.as_ptr())`
	`364`	`+ .all(\|d\| !std::ptr::eq(d.as_ptr(), dobj.as_ptr()))`
`365`	`365`	`{`
`366`	`366`	`self.orphan_objects_mut().push(dobj.downgrade());`
`367`	`367`	`}`
`@@ -493,7 +493,7 @@ impl<'gc> Avm2<'gc> {`
`493`	`493`	`for entry in bucket.iter() {`
`494`	`494`	`// Note: comparing pointers is correct because GcWeak keeps its allocation alive,`
`495`	`495`	`// so the pointers can't overlap by accident.`
`496`		`- if entry.as_ptr() == object.as_ptr() {`
	`496`	`+ if std::ptr::eq(entry.as_ptr(), object.as_ptr()) {`
`497`	`497`	`return;`
`498`	`498`	`}`
`499`	`499`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ impl<'gc> Domain<'gc> {`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`pub fn is_playerglobals_domain(&self, avm2: &Avm2<'gc>) -> bool {`
`96`		`- avm2.playerglobals_domain.0.as_ptr() == self.0.as_ptr()`
	`96`	`+ std::ptr::eq(avm2.playerglobals_domain.0.as_ptr(), self.0.as_ptr())`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`pub fn children(&self, mc: &Mutation<'gc>) -> Vec<Domain<'gc>> {`
`@@ -341,11 +341,12 @@ impl<'gc> Domain<'gc> {`
`341`	`341`
`342`	`342`	`pub fn is_default_domain_memory(&self) -> bool {`
`343`	`343`	`let read = self.0.read();`
`344`		`- read.domain_memory.expect("Missing domain memory").as_ptr()`
`345`		`- == read`
`346`		`- .default_domain_memory`
`347`		`- .expect("Missing default domain memory")`
`348`		`- .as_ptr()`
	`344`	`+ let domain_memory_ptr = read.domain_memory.expect("Missing domain memory").as_ptr();`
	`345`	`+ let default_domain_memory_ptr = read`
	`346`	`+ .default_domain_memory`
	`347`	`+ .expect("Missing default domain memory")`
	`348`	`+ .as_ptr();`
	`349`	`+ std::ptr::eq(domain_memory_ptr, default_domain_memory_ptr)`
`349`	`350`	`}`
`350`	`351`
`351`	`352`	`pub fn domain_memory(&self) -> ByteArrayObject<'gc> {`
`@@ -420,7 +421,7 @@ pub enum DomainPtr {}`
`420`	`421`
`421`	`422`	`impl PartialEq for Domain<'_> {`
`422`	`423`	`fn eq(&self, other: &Self) -> bool {`
`423`		`- self.0.as_ptr() == other.0.as_ptr()`
	`424`	`+ std::ptr::eq(self.0.as_ptr(), other.0.as_ptr())`
`424`	`425`	`}`
`425`	`426`	`}`
`426`	`427`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ impl ShaderObject for ObjectWrapper {`
`51`	`51`
`52`	`52`	`fn equals(&self, other: &dyn ShaderObject) -> bool {`
`53`	`53`	`if let Some(other_wrapper) = other.downcast_ref::<ObjectWrapper>() {`
`54`		`- self.root.as_ptr() == other_wrapper.root.as_ptr()`
	`54`	`+ std::ptr::eq(self.root.as_ptr(), other_wrapper.root.as_ptr())`
`55`	`55`	`} else {`
`56`	`56`	`false`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -916,7 +916,7 @@ pub enum ObjectPtr {}`
`916`	`916`
`917`	`917`	`impl<'gc> Object<'gc> {`
`918`	`918`	`pub fn ptr_eq<T: TObject<'gc>>(a: T, b: T) -> bool {`
`919`		`- a.as_ptr() == b.as_ptr()`
	`919`	`+ std::ptr::eq(a.as_ptr(), b.as_ptr())`
`920`	`920`	`}`
`921`	`921`
`922`	`922`	`#[rustfmt::skip]`
Original file line number	Diff line number	Diff line change
`@@ -479,7 +479,7 @@ mod wrapper {`
`479`	`479`	`self.0`
`480`	`480`	`.write(mc)`
`481`	`481`	`.display_objects`
`482`		`- .retain(\|c\| c.as_ptr() != callback.as_ptr())`
	`482`	`+ .retain(\|c\| !std::ptr::eq(c.as_ptr(), callback.as_ptr()))`
`483`	`483`	`}`
`484`	`484`
`485`	`485`	`pub fn add_display_object(&self, mc: &Mutation<'gc>, callback: DisplayObjectWeak<'gc>) {`