Merge pull request #1567 from GuillaumeGomez/msrv

GuillaumeGomez · web-flow · commit af60d22e8f95 · 2025-08-07T14:15:55.000+02:00
Update minimum supported rust version to 1.88
diff --git a/.cirrus.yml b/.cirrus.yml
@@ -1,10 +1,10 @@
 task:
-  name: rust 1.85 on freebsd 13
+  name: rust 1.88 on freebsd 13
   freebsd_instance:
     image: freebsd-13-1-release-amd64
   setup_script:
     - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile=minimal --default-toolchain=1.85
+    - sh rustup.sh -y --profile=minimal --default-toolchain=1.88
     - . $HOME/.cargo/env
     - rustup --version
     - rustup component add clippy
@@ -59,14 +59,14 @@ task:
     - FREEBSD_CI=1 cargo test --lib -- --test-threads=1
 
 task:
-  name: rust 1.85 on mac m1
+  name: rust 1.88 on mac m1
   macos_instance:
     image: ghcr.io/cirruslabs/macos-monterey-base:latest
   setup_script:
     - brew update
     - brew install curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile=minimal --default-toolchain=1.85
+    - sh rustup.sh -y --profile=minimal --default-toolchain=1.88
     - source $HOME/.cargo/env
     - rustup --version
     - rustup component add clippy
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
@@ -73,7 +73,7 @@ jobs:
           - { os: 'ubuntu-latest', target: 'x86_64-linux-android', cross: true }
           - { os: 'ubuntu-latest', target: 'i686-linux-android', cross: true }
         toolchain:
-          - "1.85.0"  # minimum supported rust version
+          - "1.88.0"  # minimum supported rust version
           - stable
           - nightly
     steps:
@@ -240,7 +240,7 @@ jobs:
           - macos-latest
           - windows-latest
         toolchain:
-          - "1.85.0"  # minimum supported rust version
+          - "1.88.0"  # minimum supported rust version
           - stable
           - nightly
     steps:
@@ -302,7 +302,7 @@ jobs:
     strategy:
       matrix:
         toolchain:
-          - "1.85.0" # minimum supported rust version
+          - "1.88.0" # minimum supported rust version
           - stable
     steps:
       - uses: actions/checkout@v4
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,7 +6,7 @@ description = "Library to get system information such as processes, CPUs, disks,
 repository = "https://github.com/GuillaumeGomez/sysinfo"
 license = "MIT"
 readme = "README.md"
-rust-version = "1.85"
+rust-version = "1.88"
 exclude = ["/test-unknown"]
 keywords = ["system-information", "disk", "process", "network", "cpu"]
 edition = "2024"
diff --git a/README.md b/README.md
@@ -18,7 +18,7 @@ You can still use `sysinfo` on non-supported OSes, it'll simply do nothing and a
 empty values. You can check in your program directly if an OS is supported by checking the
 [`IS_SUPPORTED_SYSTEM`] constant.
 
-The minimum-supported version of `rustc` is **1.85**.
+The minimum-supported version of `rustc` is **1.88**.
 
 ## Usage
 
diff --git a/src/common/system.rs b/src/common/system.rs
@@ -359,10 +359,10 @@ impl System {
             }
         }
         fn update(pid: &Pid, processes: &mut HashMap<Pid, Process>) {
-            if let Some(proc) = processes.get_mut(pid) {
-                if !proc.inner.switch_updated() {
-                    proc.inner.set_nonexistent();
-                }
+            if let Some(proc) = processes.get_mut(pid)
+                && !proc.inner.switch_updated()
+            {
+                proc.inner.set_nonexistent();
             }
         }
 
diff --git a/src/unix/apple/macos/disk.rs b/src/unix/apple/macos/disk.rs
@@ -68,12 +68,11 @@ where
                 )
             };
 
-            if let Some(properties) = properties_result {
-                if let Ok(properties) = properties.downcast::<CFDictionary>() {
-                    if let Some(result) = eval(parent_entry, &properties) {
-                        return Some(result);
-                    }
-                }
+            if let Some(properties) = properties_result
+                && let Ok(properties) = properties.downcast::<CFDictionary>()
+                && let Some(result) = eval(parent_entry, &properties)
+            {
+                return Some(result);
             }
         }
     }
diff --git a/src/unix/apple/macos/process.rs b/src/unix/apple/macos/process.rs
@@ -164,10 +164,10 @@ impl ProcessInner {
     pub(crate) fn status(&self) -> ProcessStatus {
         // If the status is `Run`, then it's very likely wrong so we instead
         // return a `ProcessStatus` converted from the `ThreadStatus`.
-        if self.process_status == ProcessStatus::Run {
-            if let Some(thread_status) = self.status {
-                return ProcessStatus::from(thread_status);
-            }
+        if self.process_status == ProcessStatus::Run
+            && let Some(thread_status) = self.status
+        {
+            return ProcessStatus::from(thread_status);
         }
         self.process_status
     }
diff --git a/src/unix/freebsd/component.rs b/src/unix/freebsd/component.rs
@@ -47,10 +47,10 @@ impl ComponentInner {
     pub(crate) fn refresh(&mut self) {
         unsafe {
             self.temperature = refresh_component(&self.id);
-            if let Some(temperature) = self.temperature {
-                if temperature > self.max {
-                    self.max = temperature;
-                }
+            if let Some(temperature) = self.temperature
+                && temperature > self.max
+            {
+                self.max = temperature;
             }
         }
     }
diff --git a/src/unix/freebsd/disk.rs b/src/unix/freebsd/disk.rs
@@ -296,18 +296,20 @@ fn get_disks_mapping() -> HashMap<String, String> {
     for line in mapping.lines() {
         let mut parts = line.split_whitespace();
         let Some(kind) = parts.next() else { continue };
+
+        #[allow(clippy::collapsible_if)]
         if kind == "0" {
-            if let Some("DISK") = parts.next() {
-                if let Some(id) = parts.next() {
-                    last_id.clear();
-                    last_id.push_str(id);
-                }
+            if let Some("DISK") = parts.next()
+                && let Some(id) = parts.next()
+            {
+                last_id.clear();
+                last_id.push_str(id);
             }
         } else if kind == "2" && !last_id.is_empty() {
-            if let Some("LABEL") = parts.next() {
-                if let Some(path) = parts.next() {
-                    disk_mapping.insert(format!("/dev/{path}"), last_id.clone());
-                }
+            if let Some("LABEL") = parts.next()
+                && let Some(path) = parts.next()
+            {
+                disk_mapping.insert(format!("/dev/{path}"), last_id.clone());
             }
         }
     }
diff --git a/src/unix/linux/cpu.rs b/src/unix/linux/cpu.rs
@@ -447,10 +447,10 @@ pub(crate) fn get_cpu_frequency(cpu_core_index: usize) -> u64 {
     .is_ok()
     {
         let freq_option = s.trim().split('\n').next();
-        if let Some(freq_string) = freq_option {
-            if let Ok(freq) = freq_string.parse::<u64>() {
-                return freq / 1000;
-            }
+        if let Some(freq_string) = freq_option
+            && let Ok(freq) = freq_string.parse::<u64>()
+        {
+            return freq / 1000;
         }
     }
     s.clear();
diff --git a/src/unix/linux/disk.rs b/src/unix/linux/disk.rs
@@ -116,15 +116,14 @@ impl DiskInner {
             self.type_ = find_type_for_device_name(&self.device_name);
         }
 
-        if refresh_kind.storage() {
-            if let Some((total_space, available_space, is_read_only)) =
+        if refresh_kind.storage()
+            && let Some((total_space, available_space, is_read_only)) =
                 unsafe { load_statvfs_values(&self.mount_point) }
-            {
-                self.total_space = total_space;
-                self.available_space = available_space;
-                if first {
-                    self.is_read_only = is_read_only;
-                }
+        {
+            self.total_space = total_space;
+            self.available_space = available_space;
+            if first {
+                self.is_read_only = is_read_only;
             }
         }
 
diff --git a/src/unix/linux/network.rs b/src/unix/linux/network.rs
@@ -22,18 +22,18 @@ macro_rules! old_and_new {
 
 #[allow(clippy::ptr_arg)]
 fn read<P: AsRef<Path>>(parent: P, path: &str, data: &mut Vec<u8>) -> u64 {
-    if let Ok(mut f) = File::open(parent.as_ref().join(path)) {
-        if let Ok(size) = f.read(data) {
-            let mut i = 0;
-            let mut ret = 0;
-
-            while i < size && i < data.len() && data[i] >= b'0' && data[i] <= b'9' {
-                ret *= 10;
-                ret += (data[i] - b'0') as u64;
-                i += 1;
-            }
-            return ret;
+    if let Ok(mut f) = File::open(parent.as_ref().join(path))
+        && let Ok(size) = f.read(data)
+    {
+        let mut i = 0;
+        let mut ret = 0;
+
+        while i < size && i < data.len() && data[i] >= b'0' && data[i] <= b'9' {
+            ret *= 10;
+            ret += (data[i] - b'0') as u64;
+            i += 1;
         }
+        return ret;
     }
     0
 }
diff --git a/src/unix/linux/process.rs b/src/unix/linux/process.rs
@@ -321,10 +321,10 @@ impl ProcessInner {
         match fs::read_to_string(&limits_files) {
             Ok(content) => {
                 for line in content.lines() {
-                    if let Some(line) = line.strip_prefix("Max open files ") {
-                        if let Some(nb) = line.split_whitespace().find(|p| !p.is_empty()) {
-                            return usize::from_str(nb).ok();
-                        }
+                    if let Some(line) = line.strip_prefix("Max open files ")
+                        && let Some(nb) = line.split_whitespace().find(|p| !p.is_empty())
+                    {
+                        return usize::from_str(nb).ok();
                     }
                 }
                 None
diff --git a/src/windows/component.rs b/src/windows/component.rs
@@ -81,12 +81,12 @@ impl ComponentInner {
         } else {
             None
         };
-        if let Some(ref mut connection) = self.connection {
-            if let Some((temperature, _)) = connection.temperature(false) {
-                self.temperature = temperature;
-                if self.temperature > self.max {
-                    self.max = self.temperature;
-                }
+        if let Some(ref mut connection) = self.connection
+            && let Some((temperature, _)) = connection.temperature(false)
+        {
+            self.temperature = temperature;
+            if self.temperature > self.max {
+                self.max = self.temperature;
             }
         }
     }
diff --git a/src/windows/cpu.rs b/src/windows/cpu.rs
@@ -47,10 +47,10 @@ fn load_avg() -> &'static Mutex<Option<LoadAvg>> {
 }
 
 pub(crate) fn get_load_average() -> LoadAvg {
-    if let Ok(avg) = load_avg().lock() {
-        if let Some(avg) = &*avg {
-            return avg.clone();
-        }
+    if let Ok(avg) = load_avg().lock()
+        && let Some(avg) = &*avg
+    {
+        return avg.clone();
     }
     LoadAvg::default()
 }
@@ -69,15 +69,15 @@ unsafe extern "system" fn load_avg_callback(counter: *mut c_void, _: bool) {
             return;
         }
         let display_value = display_value.assume_init();
-        if let Ok(mut avg) = load_avg().lock() {
-            if let Some(avg) = avg.deref_mut() {
-                let current_load = display_value.Anonymous.doubleValue;
-
-                avg.one = avg.one * LOADAVG_FACTOR_1F + current_load * (1.0 - LOADAVG_FACTOR_1F);
-                avg.five = avg.five * LOADAVG_FACTOR_5F + current_load * (1.0 - LOADAVG_FACTOR_5F);
-                avg.fifteen =
-                    avg.fifteen * LOADAVG_FACTOR_15F + current_load * (1.0 - LOADAVG_FACTOR_15F);
-            }
+        if let Ok(mut avg) = load_avg().lock()
+            && let Some(avg) = avg.deref_mut()
+        {
+            let current_load = display_value.Anonymous.doubleValue;
+
+            avg.one = avg.one * LOADAVG_FACTOR_1F + current_load * (1.0 - LOADAVG_FACTOR_1F);
+            avg.five = avg.five * LOADAVG_FACTOR_5F + current_load * (1.0 - LOADAVG_FACTOR_5F);
+            avg.fifteen =
+                avg.fifteen * LOADAVG_FACTOR_15F + current_load * (1.0 - LOADAVG_FACTOR_15F);
         }
     }
 }
diff --git a/src/windows/disk.rs b/src/windows/disk.rs
@@ -195,13 +195,12 @@ impl DiskInner {
             }
         }
 
-        if refreshes.storage() {
-            if let Some((total_space, available_space)) =
+        if refreshes.storage()
+            && let Some((total_space, available_space)) =
                 unsafe { get_drive_size(&self.mount_point) }
-            {
-                self.total_space = total_space;
-                self.available_space = available_space;
-            }
+        {
+            self.total_space = total_space;
+            self.available_space = available_space;
         }
         true
     }
diff --git a/src/windows/network_helper.rs b/src/windows/network_helper.rs
@@ -139,13 +139,13 @@ fn get_ip_networks(mut prefixes_ptr: *mut IP_ADAPTER_UNICAST_ADDRESS_LH) -> Hash
     let mut ip_networks = HashSet::new();
     while !prefixes_ptr.is_null() {
         let prefix = unsafe { prefixes_ptr.read_unaligned() };
-        if let Some(socket_address) = NonNull::new(prefix.Address.lpSockaddr) {
-            if let Some(ipaddr) = get_ip_address_from_socket_address(socket_address) {
-                ip_networks.insert(IpNetwork {
-                    addr: ipaddr,
-                    prefix: prefix.OnLinkPrefixLength,
-                });
-            }
+        if let Some(socket_address) = NonNull::new(prefix.Address.lpSockaddr)
+            && let Some(ipaddr) = get_ip_address_from_socket_address(socket_address)
+        {
+            ip_networks.insert(IpNetwork {
+                addr: ipaddr,
+                prefix: prefix.OnLinkPrefixLength,
+            });
         }
         prefixes_ptr = prefix.Next;
     }
diff --git a/src/windows/process.rs b/src/windows/process.rs
@@ -147,11 +147,11 @@ unsafe fn get_process_user_id(process: &mut ProcessInner, refresh_kind: ProcessR
 
         let mut size = 0;
 
-        if let Err(err) = GetTokenInformation(*token, TokenUser, None, 0, &mut size) {
-            if err.code() != ERROR_INSUFFICIENT_BUFFER.to_hresult() {
-                sysinfo_debug!("GetTokenInformation failed, error: {:?}", err);
-                return;
-            }
+        if let Err(err) = GetTokenInformation(*token, TokenUser, None, 0, &mut size)
+            && err.code() != ERROR_INSUFFICIENT_BUFFER.to_hresult()
+        {
+            sysinfo_debug!("GetTokenInformation failed, error: {:?}", err);
+            return;
         }
 
         let ptu: HeapWrap<TOKEN_USER> = match HeapWrap::new(size) {
@@ -606,16 +606,14 @@ unsafe fn ph_query_process_variable_size(
             return_length.as_mut_ptr() as *mut _,
         )
         .ok()
-        {
-            if ![
+            && ![
                 STATUS_BUFFER_OVERFLOW.into(),
                 STATUS_BUFFER_TOO_SMALL.into(),
                 STATUS_INFO_LENGTH_MISMATCH.into(),
             ]
             .contains(&err.code())
-            {
-                return None;
-            }
+        {
+            return None;
         }
 
         let mut return_length = return_length.assume_init();
diff --git a/src/windows/sid.rs b/src/windows/sid.rs
diff --git a/src/windows/users.rs b/src/windows/users.rs
diff --git a/tests/code_checkers/docs.rs b/tests/code_checkers/docs.rs
diff --git a/tests/code_checkers/signals.rs b/tests/code_checkers/signals.rs
diff --git a/tests/process.rs b/tests/process.rs

Original file line number	Diff line number	Diff line change
`@@ -359,10 +359,10 @@ impl System {`
`359`	`359`	`}`
`360`	`360`	`}`
`361`	`361`	`fn update(pid: &Pid, processes: &mut HashMap<Pid, Process>) {`
`362`		`- if let Some(proc) = processes.get_mut(pid) {`
`363`		`- if !proc.inner.switch_updated() {`
`364`		`- proc.inner.set_nonexistent();`
`365`		`- }`
	`362`	`+ if let Some(proc) = processes.get_mut(pid)`
	`363`	`+ && !proc.inner.switch_updated()`
	`364`	`+ {`
	`365`	`+ proc.inner.set_nonexistent();`
`366`	`366`	`}`
`367`	`367`	`}`
`368`	`368`
Original file line number	Diff line number	Diff line change
`@@ -68,12 +68,11 @@ where`
`68`	`68`	`)`
`69`	`69`	`};`
`70`	`70`
`71`		`- if let Some(properties) = properties_result {`
`72`		`- if let Ok(properties) = properties.downcast::<CFDictionary>() {`
`73`		`- if let Some(result) = eval(parent_entry, &properties) {`
`74`		`- return Some(result);`
`75`		`- }`
`76`		`- }`
	`71`	`+ if let Some(properties) = properties_result`
	`72`	`+ && let Ok(properties) = properties.downcast::<CFDictionary>()`
	`73`	`+ && let Some(result) = eval(parent_entry, &properties)`
	`74`	`+ {`
	`75`	`+ return Some(result);`
`77`	`76`	`}`
`78`	`77`	`}`
`79`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,10 +47,10 @@ impl ComponentInner {`
`47`	`47`	`pub(crate) fn refresh(&mut self) {`
`48`	`48`	`unsafe {`
`49`	`49`	`self.temperature = refresh_component(&self.id);`
`50`		`- if let Some(temperature) = self.temperature {`
`51`		`- if temperature > self.max {`
`52`		`- self.max = temperature;`
`53`		`- }`
	`50`	`+ if let Some(temperature) = self.temperature`
	`51`	`+ && temperature > self.max`
	`52`	`+ {`
	`53`	`+ self.max = temperature;`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -447,10 +447,10 @@ pub(crate) fn get_cpu_frequency(cpu_core_index: usize) -> u64 {`
`447`	`447`	`.is_ok()`
`448`	`448`	`{`
`449`	`449`	`let freq_option = s.trim().split('\n').next();`
`450`		`- if let Some(freq_string) = freq_option {`
`451`		`- if let Ok(freq) = freq_string.parse::<u64>() {`
`452`		`- return freq / 1000;`
`453`		`- }`
	`450`	`+ if let Some(freq_string) = freq_option`
	`451`	`+ && let Ok(freq) = freq_string.parse::<u64>()`
	`452`	`+ {`
	`453`	`+ return freq / 1000;`
`454`	`454`	`}`
`455`	`455`	`}`
`456`	`456`	`s.clear();`