From eff610eac677e5c96b41e6834c1330757af1ccb2 Mon Sep 17 00:00:00 2001 From: Speedy_Lex Date: Sat, 25 Apr 2026 21:00:46 +0200 Subject: [PATCH] Fix many clippy lints --- src/header/grp/mod.rs | 16 ++++---- src/header/netdb/mod.rs | 20 +++------- src/header/poll/mod.rs | 1 + src/header/signal/mod.rs | 3 -- src/header/stdio/printf.rs | 4 +- src/header/sys_syslog/logger.rs | 16 ++------ src/header/time/mod.rs | 61 ++++++++++++------------------ src/header/unistd/pathconf.rs | 14 +++---- src/header/unistd/sysconf/linux.rs | 2 +- src/header/wchar/mod.rs | 2 +- src/io/buffered.rs | 6 +-- src/io/cursor.rs | 54 +++++++++++++------------- src/io/mod.rs | 56 +++++++++++++-------------- src/ld_so/dso.rs | 1 + src/macros.rs | 1 + src/platform/mod.rs | 1 + src/pthread/mod.rs | 2 +- src/start.rs | 1 + src/sync/rwlock.rs | 10 ++--- src/sync/semaphore.rs | 11 ++---- tests/src/main.rs | 13 +++---- 21 files changed, 131 insertions(+), 164 deletions(-) diff --git a/src/header/grp/mod.rs b/src/header/grp/mod.rs index afe3599bb8..3177c1bb36 100644 --- a/src/header/grp/mod.rs +++ b/src/header/grp/mod.rs @@ -96,11 +96,11 @@ pub struct group { #[derive(Debug)] enum Error { EOF, - SyntaxError, + Syntax, BufTooSmall, Misc(io::Error), - FromUtf8Error(FromUtf8Error), - ParseIntError(ParseIntError), + FromUtf8(FromUtf8Error), + ParseInt(ParseIntError), Other, } @@ -171,9 +171,9 @@ fn parse_grp(line: String, destbuf: Option) -> Result() - .map_err(Error::ParseIntError)?; + .map_err(Error::ParseInt)?; // Place the gid at the beginning of the byte buffer to make getting it back out again later, much faster. @@ -338,9 +338,9 @@ pub unsafe extern "C" fn getgrgid_r( return match err { Error::BufTooSmall => ERANGE, Error::EOF - | Error::SyntaxError - | Error::FromUtf8Error(_) - | Error::ParseIntError(_) + | Error::Syntax + | Error::FromUtf8(_) + | Error::ParseInt(_) | Error::Other => EINVAL, Error::Misc(io_err) => match io_err.kind() { io::ErrorKind::InvalidData | io::ErrorKind::UnexpectedEof => EINVAL, diff --git a/src/header/netdb/mod.rs b/src/header/netdb/mod.rs index f1187c793f..c5964fbd3c 100644 --- a/src/header/netdb/mod.rs +++ b/src/header/netdb/mod.rs @@ -272,10 +272,8 @@ pub unsafe extern "C" fn gethostbyaddr( } //TODO actually get aliases - let mut _host_aliases: Vec> = Vec::new(); - _host_aliases.push(vec![b'\0']); - let mut host_aliases: Vec<*mut c_char> = Vec::new(); - host_aliases.push(ptr::null_mut()); + let mut _host_aliases: Vec> = vec![vec![b'\0']]; + let mut host_aliases: Vec<*mut c_char> = vec![ptr::null_mut()]; unsafe { HOST_ALIASES.unsafe_set(Some(_host_aliases)) }; match lookup_addr(addr.clone()).map(|host_names| host_names.into_iter().next()) { @@ -402,11 +400,8 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *mut hostent { unsafe { HOST_ADDR = Some(host_addr) }; //TODO actually get aliases - let mut _host_aliases: Vec> = Vec::new(); - _host_aliases.push(vec![b'\0']); - let mut host_aliases: Vec<*mut c_char> = Vec::new(); - host_aliases.push(ptr::null_mut()); - host_aliases.push(ptr::null_mut()); + let mut _host_aliases: Vec> = vec![vec![b'\0']]; + let mut host_aliases: Vec<*mut c_char> = vec![ptr::null_mut(); 2]; unsafe { HOST_ALIASES.unsafe_set(Some(_host_aliases)) }; unsafe { @@ -769,11 +764,8 @@ pub unsafe extern "C" fn getservent() -> *mut servent { *serv_aliases.push(ptr::null_mut()); * */ - let mut _serv_aliases: Vec> = Vec::new(); - _serv_aliases.push(vec![b'\0']); - let mut serv_aliases: Vec<*mut i8> = Vec::new(); - serv_aliases.push(ptr::null_mut()); - serv_aliases.push(ptr::null_mut()); + let mut _serv_aliases: Vec> = vec![vec![b'\0']]; + let mut serv_aliases: Vec<*mut i8> = vec![ptr::null_mut(); 2]; unsafe { SERV_ALIASES.unsafe_set(Some(_serv_aliases)) }; unsafe { SERV_NAME.unsafe_set(Some(serv_name)) }; diff --git a/src/header/poll/mod.rs b/src/header/poll/mod.rs index e00a03fe8d..59ab527828 100644 --- a/src/header/poll/mod.rs +++ b/src/header/poll/mod.rs @@ -95,6 +95,7 @@ pub unsafe fn poll_epoll(fds: &mut [pollfd], timeout: c_int, sigmask: *const sig continue; } + #[expect(clippy::needless_update)] let mut event = epoll_event { events: 0, data: epoll_data { u64: i as u64 }, diff --git a/src/header/signal/mod.rs b/src/header/signal/mod.rs index 584c5f4270..6eb4d4f3ea 100644 --- a/src/header/signal/mod.rs +++ b/src/header/signal/mod.rs @@ -357,7 +357,6 @@ pub extern "C" fn signal( }; let mut old_sa = mem::MaybeUninit::uninit(); if unsafe { sigaction(sig, &raw const sa, old_sa.as_mut_ptr()) } < 0 { - mem::forget(old_sa); return unsafe { mem::transmute(SIG_ERR) }; } unsafe { old_sa.assume_init() }.sa_handler @@ -467,7 +466,6 @@ pub unsafe extern "C" fn sigset( if unsafe { sigaction(sig, ptr::null_mut(), old_sa.as_mut_ptr()) } < 0 || unsafe { sigprocmask(SIG_BLOCK, &raw const set, &raw mut set) } < 0 { - mem::forget(old_sa); return sig_err; } } else { @@ -481,7 +479,6 @@ pub unsafe extern "C" fn sigset( if unsafe { sigaction(sig, &raw const sa, old_sa.as_mut_ptr()) } < 0 || unsafe { sigprocmask(SIG_UNBLOCK, &raw const set, &raw mut set) } < 0 { - mem::forget(old_sa); return sig_err; } } diff --git a/src/header/stdio/printf.rs b/src/header/stdio/printf.rs index 2f63b420ed..531f561e7b 100644 --- a/src/header/stdio/printf.rs +++ b/src/header/stdio/printf.rs @@ -193,7 +193,7 @@ impl VaArg { let ap_impl = unsafe { // The double deconstruct is intended - let ptr_to_struct = *(ap as *mut core::ffi::VaList as *mut *mut VaListImpl); + let ptr_to_struct = *(core::ptr::from_mut(ap).cast::<*mut VaListImpl>()); &mut *ptr_to_struct }; @@ -487,6 +487,7 @@ fn float_exp(mut float: c_double) -> (c_double, isize) { (float, exp) } +#[expect(clippy::too_many_arguments)] fn fmt_float_exp( w: &mut W, exp_fmt: char, @@ -524,6 +525,7 @@ fn fmt_float_exp( Ok(()) } +#[expect(clippy::too_many_arguments)] fn fmt_float_normal( w: &mut W, trim: bool, diff --git a/src/header/sys_syslog/logger.rs b/src/header/sys_syslog/logger.rs index 9a9f09c0be..af858f8602 100644 --- a/src/header/sys_syslog/logger.rs +++ b/src/header/sys_syslog/logger.rs @@ -92,17 +92,7 @@ impl LogParams { .unwrap_or(true) { // Try reopening the log file once and retrying as musl does. - if !self - .open_logger() - .is_ok() - .then(|| { - self.writer - .as_mut() - .map(|w| w.writer().write_all(&buffer).is_ok()) - .unwrap_or_default() - }) - .unwrap_or_default() - && self.opt.contains(Config::Console) + if !(self.open_logger().is_ok() && self.writer.as_mut().and_then(|w| w.writer().write_all(&buffer).ok()).is_some()) && self.opt.contains(Config::Console) { // TODO: Log error to /dev/console & Redox equivalent } @@ -139,10 +129,10 @@ impl LogParams { /// default. pub fn set_identity(&mut self, ident: Option<&str>) { self.ident = ident - .and_then(|ident| { + .map(|ident| { let ident = ident.bytes().chain([0]).collect(); // SAFETY: Already validated - Some(unsafe { String::from_utf8_unchecked(ident) }) + unsafe { String::from_utf8_unchecked(ident) } }) .unwrap_or_else(|| { unsafe { CStr::from_nullable_ptr(platform::program_invocation_short_name) } diff --git a/src/header/time/mod.rs b/src/header/time/mod.rs index 979d6a5f84..ea2b241351 100644 --- a/src/header/time/mod.rs +++ b/src/header/time/mod.rs @@ -256,6 +256,7 @@ pub extern "C" fn clock() -> clock_t { } let ts = unsafe { ts.assume_init() }; + #[expect(clippy::unnecessary_cast, reason="needed on i586")] let clocks = ts.tv_sec * CLOCKS_PER_SEC as i64 + (ts.tv_nsec / (1_000_000_000 / CLOCKS_PER_SEC)) as i64; clock_t::try_from(clocks).unwrap_or(-1) @@ -712,18 +713,12 @@ unsafe fn clear_timezone(guard: &mut MutexGuard<'_, (Option, Option { - guard.1 = - Some(CString::new(dst.offset().abbreviation().expect("Wrong timezone")).unwrap()); - tzname_mut.0[1] = guard.1.as_ref().unwrap().as_ptr().cast_mut(); - *daylight_mut = 1; - } - None => { - guard.1 = None; - tzname_mut.0[1] = guard.0.as_ref().unwrap().as_ptr().cast_mut(); - *daylight_mut = 0; + match dst { + Some(dst) => { + guard.1 = + Some(CString::new(dst.offset().abbreviation().expect("Wrong timezone")).unwrap()); + tzname.0[1] = guard.1.as_ref().unwrap().as_ptr().cast_mut(); + daylight = 1; + } + None => { + guard.1 = None; + tzname.0[1] = guard.0.as_ref().unwrap().as_ptr().cast_mut(); + daylight = 0; + } } + + timezone = -c_long::from(ut_offset.fix().local_minus_utc()); } - - *timezone_mut = -c_long::from(ut_offset.fix().local_minus_utc()); } #[inline(always)] diff --git a/src/header/unistd/pathconf.rs b/src/header/unistd/pathconf.rs index 74a90cead7..81848a719e 100644 --- a/src/header/unistd/pathconf.rs +++ b/src/header/unistd/pathconf.rs @@ -39,12 +39,12 @@ pub const _PC_2_SYMLINKS: c_int = 20; fn pc(name: c_int) -> c_long { // Settings from musl, some adjusted match name { - _PC_LINK_MAX => LINK_MAX.try_into().unwrap_or(-1), - _PC_MAX_CANON => MAX_CANON.try_into().unwrap_or(-1), - _PC_MAX_INPUT => MAX_INPUT.try_into().unwrap_or(-1), + _PC_LINK_MAX => LINK_MAX, + _PC_MAX_CANON => MAX_CANON, + _PC_MAX_INPUT => MAX_INPUT, _PC_NAME_MAX => NAME_MAX.try_into().unwrap_or(-1), _PC_PATH_MAX => PATH_MAX.try_into().unwrap_or(-1), - _PC_PIPE_BUF => PIPE_BUF.try_into().unwrap_or(-1), + _PC_PIPE_BUF => PIPE_BUF, _PC_CHOWN_RESTRICTED => 1, _PC_NO_TRUNC => 1, _PC_VDISABLE => _POSIX_VDISABLE.into(), @@ -52,13 +52,13 @@ fn pc(name: c_int) -> c_long { _PC_ASYNC_IO => -1, _PC_PRIO_IO => -1, _PC_SOCK_MAXBUF => -1, - _PC_FILESIZEBITS => FILESIZEBITS.into(), + _PC_FILESIZEBITS => FILESIZEBITS, _PC_REC_INCR_XFER_SIZE => -1, _PC_REC_MAX_XFER_SIZE => -1, _PC_REC_MIN_XFER_SIZE => 4096, _PC_REC_XFER_ALIGN => 4096, - _PC_ALLOC_SIZE_MIN => POSIX_ALLOC_SIZE_MIN.try_into().unwrap_or(-1), - _PC_SYMLINK_MAX => SYMLINK_MAX.try_into().unwrap_or(-1), + _PC_ALLOC_SIZE_MIN => POSIX_ALLOC_SIZE_MIN, + _PC_SYMLINK_MAX => SYMLINK_MAX, _PC_2_SYMLINKS => 1, _ => { platform::ERRNO.set(errno::EINVAL); diff --git a/src/header/unistd/sysconf/linux.rs b/src/header/unistd/sysconf/linux.rs index 2ec17eaf96..16426c0f6c 100644 --- a/src/header/unistd/sysconf/linux.rs +++ b/src/header/unistd/sysconf/linux.rs @@ -326,7 +326,7 @@ pub(super) fn sysconf_impl(name: c_int) -> c_long { } } _SC_V6_LPBIG_OFFBIG => -1, - _SC_HOST_NAME_MAX => HOST_NAME_MAX.try_into().unwrap_or(-1), + _SC_HOST_NAME_MAX => HOST_NAME_MAX, _SC_TRACE => -1, _SC_TRACE_EVENT_FILTER => -1, _SC_TRACE_INHERIT => -1, diff --git a/src/header/wchar/mod.rs b/src/header/wchar/mod.rs index 30c803a3f7..87fba77aff 100644 --- a/src/header/wchar/mod.rs +++ b/src/header/wchar/mod.rs @@ -331,7 +331,7 @@ pub unsafe extern "C" fn vswscanf( unsafe { let format = WStr::from_ptr(format); let s = WStr::from_ptr(s); - wscanf::scanf(s.into(), format.into(), __valist) + wscanf::scanf(s.into(), format, __valist) } } diff --git a/src/io/buffered.rs b/src/io/buffered.rs index a25273185c..4c129fb9fc 100644 --- a/src/io/buffered.rs +++ b/src/io/buffered.rs @@ -826,7 +826,7 @@ mod tests { self.pos = self.pos.wrapping_add(n as u64); } SeekFrom::End(n) => { - self.pos = u64::max_value().wrapping_add(n as u64); + self.pos = u64::MAX.wrapping_add(n as u64); } } Ok(self.pos) @@ -837,13 +837,13 @@ mod tests { assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..])); assert_eq!( reader.seek(SeekFrom::End(-5)).ok(), - Some(u64::max_value() - 5) + Some(u64::MAX - 5) ); assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5)); // the following seek will require two underlying seeks let expected = 9223372036854775802; assert_eq!( - reader.seek(SeekFrom::Current(i64::min_value())).ok(), + reader.seek(SeekFrom::Current(i64::MIN)).ok(), Some(expected) ); assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5)); diff --git a/src/io/cursor.rs b/src/io/cursor.rs index fd5500137c..66cb1b38a1 100644 --- a/src/io/cursor.rs +++ b/src/io/cursor.rs @@ -375,7 +375,7 @@ mod tests { assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; - assert_eq!(&writer.get_ref()[..], b); + assert_eq!(writer.get_ref().as_slice(), b); } #[test] @@ -386,7 +386,7 @@ mod tests { assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; - assert_eq!(&writer.get_ref()[..], b); + assert_eq!(writer.get_ref().as_slice(), b); } #[test] @@ -409,9 +409,9 @@ mod tests { #[test] fn test_buf_writer() { - let mut buf = [0 as u8; 9]; + let mut buf = [0u8; 9]; { - let mut writer = Cursor::new(&mut buf[..]); + let mut writer = Cursor::new(buf.as_mut_slice()); assert_eq!(writer.position(), 0); assert_eq!(writer.write(&[0]).unwrap(), 1); assert_eq!(writer.position(), 1); @@ -430,9 +430,9 @@ mod tests { #[test] fn test_buf_writer_seek() { - let mut buf = [0 as u8; 8]; + let mut buf = [0u8; 8]; { - let mut writer = Cursor::new(&mut buf[..]); + let mut writer = Cursor::new(buf.as_mut_slice()); assert_eq!(writer.position(), 0); assert_eq!(writer.write(&[1]).unwrap(), 1); assert_eq!(writer.position(), 1); @@ -458,8 +458,8 @@ mod tests { #[test] fn test_buf_writer_error() { - let mut buf = [0 as u8; 2]; - let mut writer = Cursor::new(&mut buf[..]); + let mut buf = [0u8; 2]; + let mut writer = Cursor::new(buf.as_mut_slice()); assert_eq!(writer.write(&[0]).unwrap(), 1); assert_eq!(writer.write(&[0, 0]).unwrap(), 1); assert_eq!(writer.write(&[0, 0]).unwrap(), 0); @@ -519,20 +519,20 @@ mod tests { #[test] fn test_slice_reader() { - let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; - let reader = &mut &in_buf[..]; + let in_buf = [0, 1, 2, 3, 4, 5, 6, 7]; + let reader = &mut in_buf.as_slice(); let mut buf = []; assert_eq!(reader.read(&mut buf).unwrap(), 0); let mut buf = [0]; assert_eq!(reader.read(&mut buf).unwrap(), 1); assert_eq!(reader.len(), 7); let b: &[_] = &[0]; - assert_eq!(&buf[..], b); + assert_eq!(&buf, b); let mut buf = [0; 4]; assert_eq!(reader.read(&mut buf).unwrap(), 4); assert_eq!(reader.len(), 3); let b: &[_] = &[1, 2, 3, 4]; - assert_eq!(&buf[..], b); + assert_eq!(&buf, b); assert_eq!(reader.read(&mut buf).unwrap(), 3); let b: &[_] = &[5, 6, 7]; assert_eq!(&buf[..3], b); @@ -541,8 +541,8 @@ mod tests { #[test] fn test_read_exact() { - let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; - let reader = &mut &in_buf[..]; + let in_buf = [0, 1, 2, 3, 4, 5, 6, 7]; + let reader = &mut in_buf.as_slice(); let mut buf = []; assert!(reader.read_exact(&mut buf).is_ok()); let mut buf = [8]; @@ -559,8 +559,8 @@ mod tests { #[test] fn test_buf_reader() { - let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; - let mut reader = Cursor::new(&in_buf[..]); + let in_buf = [0, 1, 2, 3, 4, 5, 6, 7]; + let mut reader = Cursor::new(&in_buf); let mut buf = []; assert_eq!(reader.read(&mut buf).unwrap(), 0); assert_eq!(reader.position(), 0); @@ -583,7 +583,7 @@ mod tests { #[test] fn seek_past_end() { let buf = [0xff]; - let mut r = Cursor::new(&buf[..]); + let mut r = Cursor::new(&buf); assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10); assert_eq!(r.read(&mut [0]).unwrap(), 0); @@ -592,7 +592,7 @@ mod tests { assert_eq!(r.read(&mut [0]).unwrap(), 0); let mut buf = [0]; - let mut r = Cursor::new(&mut buf[..]); + let mut r = Cursor::new(buf.as_mut_slice()); assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10); assert_eq!(r.write(&[3]).unwrap(), 0); @@ -604,7 +604,7 @@ mod tests { #[test] fn seek_past_i64() { let buf = [0xff]; - let mut r = Cursor::new(&buf[..]); + let mut r = Cursor::new(&buf); assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6); assert_eq!( r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), @@ -627,7 +627,7 @@ mod tests { assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6); let mut buf = [0]; - let mut r = Cursor::new(&mut buf[..]); + let mut r = Cursor::new(&mut buf); assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6); assert_eq!( r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), @@ -653,14 +653,14 @@ mod tests { #[test] fn seek_before_0() { let buf = [0xff]; - let mut r = Cursor::new(&buf[..]); + let mut r = Cursor::new(&buf); assert!(r.seek(SeekFrom::End(-2)).is_err()); let mut r = Cursor::new(vec![10]); assert!(r.seek(SeekFrom::End(-2)).is_err()); let mut buf = [0]; - let mut r = Cursor::new(&mut buf[..]); + let mut r = Cursor::new(&mut buf); assert!(r.seek(SeekFrom::End(-2)).is_err()); let mut r = Cursor::new(vec![10].into_boxed_slice()); @@ -677,28 +677,28 @@ mod tests { assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); assert_eq!(writer.position(), 8); let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; - assert_eq!(&writer.get_ref()[..], b); + assert_eq!(writer.get_ref().as_slice(), b); assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0); assert_eq!(writer.position(), 0); assert_eq!(writer.write(&[3, 4]).unwrap(), 2); let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7]; - assert_eq!(&writer.get_ref()[..], b); + assert_eq!(writer.get_ref().as_slice(), b); assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3); assert_eq!(writer.write(&[0, 1]).unwrap(), 2); let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7]; - assert_eq!(&writer.get_ref()[..], b); + assert_eq!(writer.get_ref().as_slice(), b); assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7); assert_eq!(writer.write(&[1, 2]).unwrap(), 2); let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2]; - assert_eq!(&writer.get_ref()[..], b); + assert_eq!(writer.get_ref().as_slice(), b); assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10); assert_eq!(writer.write(&[1]).unwrap(), 1); let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]; - assert_eq!(&writer.get_ref()[..], b); + assert_eq!(writer.get_ref().as_slice(), b); } #[test] diff --git a/src/io/mod.rs b/src/io/mod.rs index d4f09e1d2d..06790477cd 100644 --- a/src/io/mod.rs +++ b/src/io/mod.rs @@ -546,7 +546,7 @@ pub trait Read { /// let mut buffer = [0; 10]; /// /// // read up to 10 bytes - /// f.read(&mut buffer[..])?; + /// f.read(&mut buffer.as_slice())?; /// Ok(()) /// } /// ``` @@ -2032,12 +2032,12 @@ mod tests { #[test] #[cfg_attr(target_os = "emscripten", ignore)] fn read_until() { - let mut buf = Cursor::new(&b"12"[..]); + let mut buf = Cursor::new(b"12".as_slice()); let mut v = Vec::new(); assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2); assert_eq!(v, b"12"); - let mut buf = Cursor::new(&b"1233"[..]); + let mut buf = Cursor::new(b"1233".as_slice()); let mut v = Vec::new(); assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3); assert_eq!(v, b"123"); @@ -2051,12 +2051,12 @@ mod tests { #[test] fn split() { - let buf = Cursor::new(&b"12"[..]); + let buf = Cursor::new(b"12".as_slice()); let mut s = buf.split(b'3'); assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']); assert!(s.next().is_none()); - let buf = Cursor::new(&b"1233"[..]); + let buf = Cursor::new(b"1233".as_slice()); let mut s = buf.split(b'3'); assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']); assert_eq!(s.next().unwrap().unwrap(), vec![]); @@ -2065,12 +2065,12 @@ mod tests { #[test] fn read_line() { - let mut buf = Cursor::new(&b"12"[..]); + let mut buf = Cursor::new(b"12".as_slice()); let mut v = String::new(); assert_eq!(buf.read_line(&mut v).unwrap(), 2); assert_eq!(v, "12"); - let mut buf = Cursor::new(&b"12\n\n"[..]); + let mut buf = Cursor::new(b"12\n\n".as_slice()); let mut v = String::new(); assert_eq!(buf.read_line(&mut v).unwrap(), 3); assert_eq!(v, "12\n"); @@ -2084,12 +2084,12 @@ mod tests { // #[test] // fn lines() { - // let buf = Cursor::new(&b"12\r"[..]); + // let buf = Cursor::new(b"12\r".as_slice()); // let mut s = buf.lines(); // assert_eq!(s.next().unwrap().unwrap(), "12\r".to_string()); // assert!(s.next().is_none()); - // let buf = Cursor::new(&b"12\r\n\n"[..]); + // let buf = Cursor::new(b"12\r\n\n".as_slice()); // let mut s = buf.lines(); // assert_eq!(s.next().unwrap().unwrap(), "12".to_string()); // assert_eq!(s.next().unwrap().unwrap(), "".to_string()); @@ -2098,12 +2098,12 @@ mod tests { #[test] fn read_to_end() { - let mut c = Cursor::new(&b""[..]); + let mut c = Cursor::new(b"".as_slice()); let mut v = Vec::new(); assert_eq!(c.read_to_end(&mut v).unwrap(), 0); assert_eq!(v, []); - let mut c = Cursor::new(&b"1"[..]); + let mut c = Cursor::new(b"1".as_slice()); let mut v = Vec::new(); assert_eq!(c.read_to_end(&mut v).unwrap(), 1); assert_eq!(v, b"1"); @@ -2119,17 +2119,17 @@ mod tests { #[test] fn read_to_string() { - let mut c = Cursor::new(&b""[..]); + let mut c = Cursor::new(b"".as_slice()); let mut v = String::new(); assert_eq!(c.read_to_string(&mut v).unwrap(), 0); assert_eq!(v, ""); - let mut c = Cursor::new(&b"1"[..]); + let mut c = Cursor::new(b"1".as_slice()); let mut v = String::new(); assert_eq!(c.read_to_string(&mut v).unwrap(), 1); assert_eq!(v, "1"); - let mut c = Cursor::new(&b"\xff"[..]); + let mut c = Cursor::new(b"\xff".as_slice()); let mut v = String::new(); assert!(c.read_to_string(&mut v).is_err()); } @@ -2138,17 +2138,17 @@ mod tests { fn read_exact() { let mut buf = [0; 4]; - let mut c = Cursor::new(&b""[..]); + let mut c = Cursor::new(b"".as_slice()); assert_eq!( c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof ); - let mut c = Cursor::new(&b"123"[..]).chain(Cursor::new(&b"456789"[..])); + let mut c = Cursor::new(b"123".as_slice()).chain(Cursor::new(b"456789".as_slice())); c.read_exact(&mut buf).unwrap(); - assert_eq!(&buf, b"1234"); + assert_eq!(buf, *b"1234"); c.read_exact(&mut buf).unwrap(); - assert_eq!(&buf, b"5678"); + assert_eq!(buf, *b"5678"); assert_eq!( c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof @@ -2159,27 +2159,27 @@ mod tests { fn read_exact_slice() { let mut buf = [0; 4]; - let mut c = &b""[..]; + let mut c = b"".as_slice(); assert_eq!( c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof ); - let mut c = &b"123"[..]; + let mut c = b"123".as_slice(); assert_eq!( c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof ); // make sure the optimized (early returning) method is being used - assert_eq!(&buf, &[0; 4]); + assert_eq!(buf, [0; 4]); - let mut c = &b"1234"[..]; + let mut c = b"1234".as_slice(); c.read_exact(&mut buf).unwrap(); - assert_eq!(&buf, b"1234"); + assert_eq!(buf, *b"1234"); - let mut c = &b"56789"[..]; + let mut c = b"56789".as_slice(); c.read_exact(&mut buf).unwrap(); - assert_eq!(&buf, b"5678"); + assert_eq!(buf, *b"5678"); assert_eq!(c, b"9"); } @@ -2227,7 +2227,7 @@ mod tests { } assert_eq!(br1.fill_buf().unwrap().len(), 0); assert_eq!(br2.fill_buf().unwrap().len(), 0); - assert_eq!(&cat[..], &exp[..]) + assert_eq!(&cat, &exp) } #[test] @@ -2240,7 +2240,7 @@ mod tests { let chain2 = (&testdata[..4]) .chain(&testdata[4..8]) .chain(&testdata[8..]); - cmp_bufread(chain1, chain2, &testdata[..]); + cmp_bufread(chain1, chain2, testdata.as_slice()); } #[test] @@ -2248,7 +2248,7 @@ mod tests { let a = b"A"; let b = b"B"; let mut s = String::new(); - let mut chain = (&a[..]).chain(&b[..]); + let mut chain = a.chain(b.as_slice()); chain.read(&mut []).unwrap(); chain.read_to_string(&mut s).unwrap(); assert_eq!("AB", s); diff --git a/src/ld_so/dso.rs b/src/ld_so/dso.rs index 3bf4a833cb..0dca18eb2b 100644 --- a/src/ld_so/dso.rs +++ b/src/ld_so/dso.rs @@ -774,6 +774,7 @@ impl DSO { let strtab_offset = strtab_offset.expect("mandatory DT_STRTAB not present"); let strtab_size = strtab_size.expect("mandatory DT_STRSZ not present"); + #[expect(clippy::unnecessary_cast, reason="needed on i586")] let dynstrtab = StringTable::new( mmap, strtab_offset as u64, diff --git a/src/macros.rs b/src/macros.rs index 72b4e414db..7ce4ff9505 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -574,6 +574,7 @@ macro_rules! CheckVsLibcCrate { const _: () = { fn ensure_ty(a: A, b: B) where (): $crate::macros::LibcTypeEquals:: {} fn for_libc(a: $name, b: __libc_only_for_layout_checks::$name) { + #[allow(clippy::diverging_sub_expression)] let a: $type = panic!("never called"); ensure_ty(a, b.$field); } diff --git a/src/platform/mod.rs b/src/platform/mod.rs index d3a10b92a5..737dada4ed 100644 --- a/src/platform/mod.rs +++ b/src/platform/mod.rs @@ -417,5 +417,6 @@ pub unsafe fn init_inner(auxvs: Box<[[usize; 2]]>) { redox_rt::sys::swap_umask((umask as u32) & u32::from(MODE_PERM) & !(S_ISVTX as u32)); } } +#[expect(clippy::boxed_local)] #[cfg(not(target_os = "redox"))] pub unsafe fn init(auxvs: Box<[[usize; 2]]>) {} diff --git a/src/pthread/mod.rs b/src/pthread/mod.rs index 8243a48079..9b1f100de5 100644 --- a/src/pthread/mod.rs +++ b/src/pthread/mod.rs @@ -234,7 +234,7 @@ unsafe extern "C" fn new_thread_shim( unsafe { tcb.copy_masters() }.unwrap(); - unsafe { (*tcb).pthread.os_tid.get().write(Sys::current_os_tid()) }; + unsafe { tcb.pthread.os_tid.get().write(Sys::current_os_tid()) }; unsafe { (&*synchronization_mutex).manual_unlock() }; diff --git a/src/start.rs b/src/start.rs index 63d404607b..a21a35ea29 100644 --- a/src/start.rs +++ b/src/start.rs @@ -57,6 +57,7 @@ unsafe fn copy_string_array(array: *const *const c_char, len: usize) -> Vec<*mut let mut offset = 0; let buf = unsafe { platform::alloc(size).cast::() }; + #[expect(clippy::needless_range_loop)] for i in 0..len { let dest_buf = unsafe { buf.add(offset) }; let item = unsafe { *array.add(i) }; diff --git a/src/sync/rwlock.rs b/src/sync/rwlock.rs index cfd834b8d9..c729132677 100644 --- a/src/sync/rwlock.rs +++ b/src/sync/rwlock.rs @@ -74,9 +74,8 @@ impl InnerRwLock { waiting_wr = expected & WAITING_WR; if actual & COUNT_MASK > 0 { - match crate::sync::futex_wait(&self.state, expected, relative.as_ref()) { - super::FutexWaitResult::TimedOut => return Err(Errno(ETIMEDOUT)), - _ => {} + if crate::sync::futex_wait(&self.state, expected, relative.as_ref()) == super::FutexWaitResult::TimedOut { + return Err(Errno(ETIMEDOUT)) } } else { // We must avoid blocking indefinitely in our `futex_wait()`, in this case @@ -94,9 +93,8 @@ impl InnerRwLock { pub fn acquire_read_lock(&self, deadline: Option<(×pec, clockid_t)>) -> Result<(), Errno> { let relative = Self::translate_timeout(deadline)?; while let Err(old) = self.try_acquire_read_lock() { - match crate::sync::futex_wait(&self.state, old, relative.as_ref()) { - super::FutexWaitResult::TimedOut => return Err(Errno(ETIMEDOUT)), - _ => {} + if crate::sync::futex_wait(&self.state, old, relative.as_ref()) == super::FutexWaitResult::TimedOut { + return Err(Errno(ETIMEDOUT)) } } diff --git a/src/sync/semaphore.rs b/src/sync/semaphore.rs index b3ae2f04b9..1478aa3148 100644 --- a/src/sync/semaphore.rs +++ b/src/sync/semaphore.rs @@ -35,17 +35,14 @@ impl Semaphore { return 0; } - match self.count.compare_exchange_weak( + if self.count.compare_exchange_weak( value, value - 1, Ordering::SeqCst, Ordering::SeqCst, - ) { - Ok(_) => { - // Acquired - return value; - } - Err(_) => (), + ).is_ok() { + // Acquired + return value; } // Try again (as long as value > 0) } diff --git a/tests/src/main.rs b/tests/src/main.rs index 69f3024766..88762b3118 100644 --- a/tests/src/main.rs +++ b/tests/src/main.rs @@ -26,13 +26,10 @@ fn find_expected_dir() -> Option { } } - if found_expected_dir.is_none() { - if let Ok(cwd) = env::current_dir() { - let check = cwd.join("expected"); - if check.is_dir() { + if found_expected_dir.is_none() + && let Ok(check) = env::current_dir().map(|cwd| cwd.join("expected")) + && check.is_dir(){ found_expected_dir = Some(check); - } - } } found_expected_dir @@ -85,10 +82,10 @@ fn expected( if expected != generated { println!("# {}: {}: expected #", bin, kind); - io::stdout().write(&expected).unwrap(); + io::stdout().write_all(&expected).unwrap(); println!("# {}: {}: generated #", bin, kind); - io::stdout().write(generated).unwrap(); + io::stdout().write_all(generated).unwrap(); return Err(format!( "{} failed - retcode {}, {} mismatch",