Skip to contentSkip to conversation

rust: error: allow `useless_conversion` for 32-bit builds

PATCH Applied Miguel Ojeda 4 participants 5 messages Jul 30, 2024 – Aug 18, 2024 Rust

lore
Share & tools
lore

Miguel Ojeda

author maintainer
#0 lore raw

PATCH 1/1 rust: error: allow `useless_conversion` for 32-bit builds

For the new Rust support for 32-bit arm [1], Clippy warns:

    error: useless conversion to the same type: `i32`
       --> rust/kernel/error.rs:139:36
        |
    139 |         unsafe { bindings::ERR_PTR(self.0.into()) as *mut _ }
        |                                    ^^^^^^^^^^^^^ help: consider removing `.into()`: `self.0`
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
        = note: `-D clippy::useless-conversion` implied by `-D warnings`
        = help: to override `-D warnings` add `#[allow(clippy::useless_conversion)]`

The self.0.into() converts an c_int into ERR_PTR's parameter which is a c_long. Thus, both types are i32 in 32-bit. Therefore, allow it for those architectures.

---
 rust/kernel/error.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
rust/kernel/error.rs +4 -1
index 145f5c397009..6f1587a2524e 100644
@@ -135,8 +135,11 @@ pub(crate) fn to_blk_status(self) -> bindings::blk_status_t {
     /// Returns the error encoded as a pointer.
     #[allow(dead_code)]
     pub(crate) fn to_ptr<T>(self) -> *mut T {
+        #[cfg_attr(target_pointer_width = "32", allow(clippy::useless_conversion))]
         // SAFETY: `self.0` is a valid error due to its invariant.
-        unsafe { bindings::ERR_PTR(self.0.into()) as *mut _ }
+        unsafe {
+            bindings::ERR_PTR(self.0.into()) as *mut _
+        }
     }
 
     /// Returns a string representing the error, if one exists.

base-commit: 8400291e289ee6b2bf9779ff1c83a291501f017b

Signature · 1 line
2.46.0
reviewer Reviewed-by on v1 1/1
#1 lore raw
Quoted 28 lines · Miguel Ojeda

For the new Rust support for 32-bit arm [1], Clippy warns:

    error: useless conversion to the same type: `i32`
       --> rust/kernel/error.rs:139:36
        |
    139 |         unsafe { bindings::ERR_PTR(self.0.into()) as *mut _ }
        |                                    ^^^^^^^^^^^^^ help: consider removing `.into()`: `self.0`
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
        = note: `-D clippy::useless-conversion` implied by `-D warnings`
        = help: to override `-D warnings` add `#[allow(clippy::useless_conversion)]`

The self.0.into() converts an c_int into ERR_PTR's parameter which is a c_long. Thus, both types are i32 in 32-bit. Therefore, allow it for those architectures.

---
 rust/kernel/error.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
rust/kernel/error.rs +0 -0
index 145f5c397009..6f1587a2524e 100644

rust/kernel/error.rs pub(crate) fn to_blk_status(self) -> bindings::blk_status_t { · line 143

Quoted 10 lines
rust/kernel/error.rs +4 -1
@@ -135,8 +135,11 @@ pub(crate) fn to_blk_status(self) -> bindings::blk_status_t {
     /// Returns the error encoded as a pointer.
     #[allow(dead_code)]
     pub(crate) fn to_ptr<T>(self) -> *mut T {
+        #[cfg_attr(target_pointer_width = "32", allow(clippy::useless_conversion))]
         // SAFETY: `self.0` is a valid error due to its invariant.
-        unsafe { bindings::ERR_PTR(self.0.into()) as *mut _ }
+        unsafe {
+            bindings::ERR_PTR(self.0.into()) as *mut _
+        }
     }

The formatting here is a bit weird. Perhaps we should swap the cfg and the comment?

Either way, it looks good to me.

#2 lore raw
Quoted 3 lines · Alice Ryhl

The formatting here is a bit weird. Perhaps we should swap the cfg and the comment?

Yeah, I don't like it either -- I reflexively did it because in the safety series I am sending, there was a case where it would not notice the // SAFETY comment if an attribute was placed afterwards.

But for blocks like this works fine, so it is not needed here, so we can change it, even we may need to be inconsistent in a few places about this, at least until it is fixed (assuming it is indeed a false positive).

I created an issue in Clippy about it:
https://github.com/rust-lang/rust-clippy/issues/13189.

Thanks!

Cheers,
Miguel

#3 lore raw
In reply to Miguel Ojeda
Quoted 40 lines · Miguel Ojeda

For the new Rust support for 32-bit arm [1], Clippy warns:

    error: useless conversion to the same type: `i32`
       --> rust/kernel/error.rs:139:36
        |
    139 |         unsafe { bindings::ERR_PTR(self.0.into()) as *mut _ }
        |                                    ^^^^^^^^^^^^^ help: consider removing `.into()`: `self.0`
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
        = note: `-D clippy::useless-conversion` implied by `-D warnings`
        = help: to override `-D warnings` add `#[allow(clippy::useless_conversion)]`

The self.0.into() converts an c_int into ERR_PTR's parameter which is a c_long. Thus, both types are i32 in 32-bit. Therefore, allow it for those architectures.

---
 rust/kernel/error.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
rust/kernel/error.rs +4 -1
index 145f5c397009..6f1587a2524e 100644
@@ -135,8 +135,11 @@ pub(crate) fn to_blk_status(self) -> bindings::blk_status_t {
     /// Returns the error encoded as a pointer.
     #[allow(dead_code)]
     pub(crate) fn to_ptr<T>(self) -> *mut T {
+        #[cfg_attr(target_pointer_width = "32", allow(clippy::useless_conversion))]
         // SAFETY: `self.0` is a valid error due to its invariant.
-        unsafe { bindings::ERR_PTR(self.0.into()) as *mut _ }
+        unsafe {
+            bindings::ERR_PTR(self.0.into()) as *mut _
+        }
     }
 
     /// Returns a string representing the error, if one exists.
Quoted 1 line

base-commit: 8400291e289ee6b2bf9779ff1c83a291501f017b

Seems good to me.

If I create another version of the arm support I'll include this there, otherwise:

Applied
#4 lore raw
In reply to Miguel Ojeda
Quoted 13 lines · Miguel Ojeda

For the new Rust support for 32-bit arm [1], Clippy warns:

    error: useless conversion to the same type: `i32`
       --> rust/kernel/error.rs:139:36
        |
    139 |         unsafe { bindings::ERR_PTR(self.0.into()) as *mut _ }
        |                                    ^^^^^^^^^^^^^ help: consider removing `.into()`: `self.0`
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
        = note: `-D clippy::useless-conversion` implied by `-D warnings`
        = help: to override `-D warnings` add `#[allow(clippy::useless_conversion)]`
Quoted 6 lines

The self.0.into() converts an c_int into ERR_PTR's parameter which is a c_long. Thus, both types are i32 in 32-bit. Therefore, allow it for those architectures.

Applied to rust-next -- thanks everyone!

[ Fixed typo in tag. - Miguel ]

We can also change the formatting later on top of the series that will enable that lint.

Cheers,
Miguel