refactor: replace <_>::max_value() with <_>::MAX

The `<_>::max_value()` methods are soft-deprecated.

Author: yvt

src/constance/src/kernel/cfg.rs

@@ -536,8 +536,8 @@ impl<System> CfgBuilder<System> {
             panic!("`num_task_priority_levels` must be greater than zero");
         } else if new_value > FIXED_PRIO_BITMAP_MAX_LEN {
             panic!("`num_task_priority_levels` must be less than or equal to `FIXED_PRIO_BITMAP_MAX_LEN`");
-        } else if new_value >= isize::max_value() as usize {
-            // Limiting priority values in range `0..(isize::max_value() - 1)`
+        } else if new_value >= isize::MAX as usize {
+            // Limiting priority values in range `0..(isize::MAX - 1)`
             // leaves room for special values outside the extremities.
             //
             // This branch is actually unreachable because

src/constance/src/kernel/task.rs

@@ -553,15 +553,15 @@ pub(super) fn unlock_cpu_and_check_preemption<System: Kernel>(lock: utils::CpuLo
     let prev_task_priority = if let Some(running_task) = System::state().running_task() {
         running_task.priority.to_usize().unwrap()
     } else {
-        usize::max_value()
+        usize::MAX
     };
 
     // The priority of the next task to run
     let next_task_priority = System::state()
         .task_ready_bitmap
         .read(&*lock)
         .find_set()
-        .unwrap_or(usize::max_value());
+        .unwrap_or(usize::MAX);
 
     // Relinquish CPU Lock
     drop(lock);
@@ -593,30 +593,30 @@ pub(super) fn choose_next_running_task<System: Kernel>(
         if *running_task.st.read(&*lock) == TaskSt::Running {
             running_task.priority.to_usize().unwrap()
         } else {
-            usize::max_value()
+            usize::MAX
         }
     } else {
-        usize::max_value()
+        usize::MAX
     };
 
     // The priority of the next task to run
     //
-    // The default value is `usize::max_value() - 1` for the following reason:
+    // The default value is `usize::MAX - 1` for the following reason:
     // If `running_task` is in the Waiting state and there's no other task to
     // schedule at the moment, we want to assign `None` to `running_task`. In
     // this case, if the default value was the same as `prev_task_priority`,
     // `prev_task_priority` would be equal to `next_task_priority`, and the
     // `if` statement below would return too early. We make sure this does not
     // happen by making the default value of `next_task_priority` lower.
     //
-    // `usize::max_value()` never collides with an actual task priority because
+    // `usize::MAX - 1` never collides with an actual task priority because
     // of the priority range restriction imposed by `CfgBuilder::
     // num_task_priority_levels`.
     let next_task_priority = System::state()
         .task_ready_bitmap
         .read(&*lock)
         .find_set()
-        .unwrap_or(usize::max_value() - 1);
+        .unwrap_or(usize::MAX - 1);
 
     // Return if there's no task willing to take over the current one, and
     // the current one can still run.

src/constance/src/utils/int.rs

@@ -6,13 +6,13 @@ use super::{Init, ZeroInit};
 /// Get the smallest unsigned integer type capable of representing the specified
 /// value.
 pub type UIntegerWithBound<const MAX: u128> = If! {
-    if (MAX <= u8::max_value() as u128) {
+    if (MAX <= u8::MAX as u128) {
         u8
-    } else if (MAX <= u16::max_value() as u128) {
+    } else if (MAX <= u16::MAX as u128) {
         u16
-    } else if (MAX <= u32::max_value() as u128) {
+    } else if (MAX <= u32::MAX as u128) {
         u32
-    } else if (MAX <= u64::max_value() as u128) {
+    } else if (MAX <= u64::MAX as u128) {
         u64
     } else {
         u128

src/constance_port_std/src/lib.rs

@@ -779,7 +779,7 @@ macro_rules! use_port {
 
             unsafe impl PortInterrupts for $sys {
                 const MANAGED_INTERRUPT_PRIORITY_RANGE:
-                    ::std::ops::Range<InterruptPriority> = 0..InterruptPriority::max_value();
+                    ::std::ops::Range<InterruptPriority> = 0..InterruptPriority::MAX;
 
                 unsafe fn set_interrupt_line_priority(
                     line: InterruptNum,

src/constance_port_std/src/utils/iterpool.rs

@@ -91,7 +91,7 @@ impl PoolPtr {
 
     /// Construct a `PoolPtr` from a given `x: usize`.
     ///
-    /// `x` must be less than `usize::max_value()`.
+    /// `x` must be less than `usize::MAX`.
     pub fn new(x: usize) -> Self {
         PoolPtr(NonZeroUsize::new(x.wrapping_add(1)).expect("count overflow"))
     }