refactor(r3): Option::expect is now unstably const fn

<rust-lang/rust#90269> (merged on Dec 3, 2021)

Author: yvt

src/r3/src/kernel/hook.rs

@@ -108,12 +108,7 @@ impl<System: raw::KernelBase> StartupHookDefiner<System> {
         let startup_hooks = &mut cfg.startup_hooks;
         let order = startup_hooks.len();
         startup_hooks.push(CfgStartupHook {
-            // FIXME: Work-around for `Option::expect` being not `const fn`
-            start: if let Some(x) = self.start {
-                x
-            } else {
-                panic!("`start` is not specified")
-            },
+            start: self.start.expect("`start` is not specified"),
             param: self.param,
             priority: self.priority,
             order,

src/r3/src/kernel/interrupt.rs

@@ -231,12 +231,7 @@ impl<System: raw::KernelInterruptLine> InterruptLineDefiner<System> {
         self,
         cfg: &mut Cfg<C>,
     ) -> InterruptLine<System> {
-        // FIXME: Work-around for `Option::expect` being not `const fn`
-        let line_num = if let Some(line) = self.line {
-            line
-        } else {
-            panic!("`line` is not specified");
-        };
+        let line_num = self.line.expect("`line` is not specified");
 
         // Create a `CfgBuilderInterruptLine` for `line_num` if it doesn't exist
         // yet
@@ -358,25 +353,15 @@ impl<System: raw::KernelInterruptLine> InterruptHandlerDefiner<System> {
         self,
         cfg: &mut Cfg<C>,
     ) -> InterruptHandler<System> {
-        // FIXME: Work-around for `Option::expect` being not `const fn`
-        let line_num = if let Some(line) = self.line {
-            line
-        } else {
-            panic!("`line` is not specified");
-        };
+        let line_num = self.line.expect("`line` is not specified");
 
         // Add a `CfgInterruptLineInfo` at the same time
         InterruptLine::define().line(line_num).finish(cfg);
 
         let order = cfg.interrupt_handlers.len();
         cfg.interrupt_handlers.push(CfgInterruptHandler {
             line: line_num,
-            // FIXME: Work-around for `Option::expect` being not `const fn`
-            start: if let Some(x) = self.start {
-                x
-            } else {
-                panic!("`start` is not specified")
-            },
+            start: self.start.expect("`start` is not specified"),
             param: self.param,
             priority: self.priority,
             unmanaged: self.unmanaged,

src/r3/src/kernel/semaphore.rs

@@ -231,16 +231,8 @@ impl<System: raw::KernelSemaphore> SemaphoreDefiner<System> {
         self,
         c: &mut Cfg<C>,
     ) -> Semaphore<System> {
-        let initial_value = if let Some(x) = self.initial_value {
-            x
-        } else {
-            panic!("`initial` is not specified")
-        };
-        let maximum_value = if let Some(x) = self.maximum_value {
-            x
-        } else {
-            panic!("`maximum` is not specified")
-        };
+        let initial_value = self.initial_value.expect("`initial` is not specified");
+        let maximum_value = self.maximum_value.expect("`maximum` is not specified");
 
         let id = c.raw().semaphore_define(
             raw_cfg::SemaphoreDescriptor {

src/r3/src/kernel/task.rs

@@ -343,18 +343,14 @@ impl<System: raw::KernelBase> TaskDefiner<System> {
         let id = cfg.raw().task_define(
             raw_cfg::TaskDescriptor {
                 phantom: Init::INIT,
-                start: if let Some(x) = self.start {
-                    x
-                } else {
-                    panic!("`start` (task entry point) is not specified")
-                },
+                start: self
+                    .start
+                    .expect("`start` (task entry point) is not specified"),
                 param: self.param,
                 active: self.active,
-                priority: if let Some(x) = self.priority {
-                    x
-                } else {
-                    panic!("`priority` (task entry point) is not specified")
-                },
+                priority: self
+                    .priority
+                    .expect("`priority` (task entry point) is not specified"),
                 stack_size: self.stack_size,
             },
             (),

src/r3/src/kernel/timer.rs

@@ -542,12 +542,9 @@ impl<System: raw::KernelTimer> TimerDefiner<System> {
         let id = c.raw().timer_define(
             raw_cfg::TimerDescriptor {
                 phantom: Init::INIT,
-                // FIXME: Work-around for `Option::expect` being not `const fn`
-                start: if let Some(x) = self.start {
-                    x
-                } else {
-                    panic!("`start` (timer callback function) is not specified")
-                },
+                start: self
+                    .start
+                    .expect("`start` (timer callback function) is not specified"),
                 param: self.param,
                 delay: self.delay,
                 period: self.period,

src/r3/src/time/duration.rs

@@ -47,25 +47,15 @@ impl Duration {
     /// Pancis if `millis` overflows the representable range of `Duration`.
     #[inline]
     pub const fn from_millis(millis: i32) -> Self {
-        // FIXME: `Option::expect` is not `const fn` yet
-        Self::from_micros(if let Some(x) = millis.checked_mul(1_000) {
-            x
-        } else {
-            panic!("duration overflow");
-        })
+        Self::from_micros(millis.checked_mul(1_000).expect("duration overflow"))
     }
 
     /// Construct a new `Duration` from the specified number of seconds.
     ///
     /// Pancis if `secs` overflows the representable range of `Duration`.
     #[inline]
     pub const fn from_secs(secs: i32) -> Self {
-        // FIXME: `Option::expect` is not `const fn` yet
-        Self::from_micros(if let Some(x) = secs.checked_mul(1_000_000) {
-            x
-        } else {
-            panic!("duration overflow");
-        })
+        Self::from_micros(secs.checked_mul(1_000_000).expect("duration overflow"))
     }
 
     /// Get the total number of whole microseconds contained by this `Duration`.

src/r3/src/time/time.rs

@@ -51,25 +51,15 @@ impl Time {
     /// Pancis if `millis` overflows the representable range of `Time`.
     #[inline]
     pub const fn from_millis(millis: u64) -> Self {
-        // FIXME: `Option::expect` is not `const fn` yet
-        Self::from_micros(if let Some(x) = millis.checked_mul(1_000) {
-            x
-        } else {
-            panic!("duration overflow");
-        })
+        Self::from_micros(millis.checked_mul(1_000).expect("duration overflow"))
     }
 
     /// Construct a new `Time` from the specified number of seconds.
     ///
     /// Pancis if `secs` overflows the representable range of `Time`.
     #[inline]
     pub const fn from_secs(secs: u64) -> Self {
-        // FIXME: `Option::expect` is not `const fn` yet
-        Self::from_micros(if let Some(x) = secs.checked_mul(1_000_000) {
-            x
-        } else {
-            panic!("duration overflow");
-        })
+        Self::from_micros(secs.checked_mul(1_000_000).expect("duration overflow"))
     }
 
     /// Get the total number of whole microseconds contained in the time span