clippy: use if let Some()

Signed-off-by: Krishnan Winter <krishnan.winter@unsw.edu.au>

Author: Kswin01

tool/microkit/src/capdl/builder.rs

@@ -700,19 +700,16 @@ pub fn build_capdl_spec(
         ));
 
         // Step 3-5 Create fault Endpoint cap to parent/monitor
-        let pd_fault_ep_cap = if pd.parent.is_none() {
-            let badge: u64 = mon_pd_idx as u64 + 1;
-            capdl_util_make_endpoint_cap(mon_fault_ep_obj_id, true, true, true, badge)
-        } else {
+        let pd_fault_ep_cap = if let Some(parent) = pd.parent {
             // @kwinter: Should we enforce domain boundaries here?
-            assert!(pd_global_idx > pd.parent.unwrap());
+            assert!(pd_global_idx > parent);
             let badge: u64 = FAULT_BADGE | pd.id.unwrap();
-            let parent_ep_obj_id = &pd_id_to_ep_id[&pd.parent.unwrap()];
+            let parent_ep_obj_id = &pd_id_to_ep_id[&parent];
             let fault_ep_cap =
                 capdl_util_make_endpoint_cap(*parent_ep_obj_id, true, true, true, badge);
 
             // Allow the parent PD to access the child's TCB:
-            let parent_cspace_obj_id = &pd_id_to_cspace_id[&pd.parent.unwrap()];
+            let parent_cspace_obj_id = &pd_id_to_cspace_id[&parent];
             capdl_util_insert_cap_into_cspace(
                 &mut spec_container,
                 *parent_cspace_obj_id,
@@ -721,7 +718,11 @@ pub fn build_capdl_spec(
             );
 
             fault_ep_cap
+        } else {
+            let badge: u64 = mon_pd_idx as u64 + 1;
+            capdl_util_make_endpoint_cap(mon_fault_ep_obj_id, true, true, true, badge)
         };
+
         caps_to_insert_to_pd_cspace.push(capdl_util_make_cte(
             PD_FAULT_EP_CAP_IDX as u32,
             pd_fault_ep_cap.clone(),
@@ -1125,38 +1126,28 @@ pub fn build_capdl_spec(
     // Step 5. Parse domain schedule
     // *********************************
 
-    if system.domain_schedule.is_some() {
+    if let Some(sys_domain_schedule) = &system.domain_schedule {
         let mut domain_schedule: Vec<DomainSchedEntry> = Vec::new();
         // We want to convert from the microseconds that the user defines in the
         // sdf to the kernel scheduler ticks. If we are on x86, we won't necessarily
         // have a static definition of the timer frequency. We will express the
         // domain timeslices in ticks.
-        let ticks_in_ms = if kernel_config.timer_freq.is_some() {
-            kernel_config.timer_freq.unwrap() / US_IN_S
+        let ticks_in_ms = if let Some(timer_freq) = kernel_config.timer_freq {
+            timer_freq / US_IN_S
         } else {
             1
         };
 
-        for sched_entry in system.domain_schedule.as_ref().unwrap().schedule.iter() {
+        for sched_entry in sys_domain_schedule.schedule.iter() {
             domain_schedule.push(DomainSchedEntry {
                 id: sched_entry.id,
                 time: sched_entry.length * ticks_in_ms,
             });
         }
 
         spec_container.spec.domain_schedule = Some(domain_schedule);
-        spec_container.spec.domain_set_start = system
-            .domain_schedule
-            .as_ref()
-            .unwrap()
-            .domain_start_idx
-            .map(Word);
-        spec_container.spec.domain_idx_shift = system
-            .domain_schedule
-            .as_ref()
-            .unwrap()
-            .domain_idx_shift
-            .map(Word);
+        spec_container.spec.domain_set_start = sys_domain_schedule.domain_start_idx.map(Word);
+        spec_container.spec.domain_idx_shift = sys_domain_schedule.domain_idx_shift.map(Word);
     }
 
     // *********************************

tool/microkit/src/sdf.rs

@@ -1183,10 +1183,10 @@ impl DomainSchedule {
                     });
                 }
                 "domain_start" => {
-                    if domain_start_idx.is_some() {
+                    if let Some(domain_start_idx) = domain_start_idx {
                         return Err(format!(
                             "Error: Duplicate setting of domain start index, already set to '{}'",
-                            domain_start_idx.unwrap()
+                            domain_start_idx
                         ));
                     }
                     check_attributes(xml_sdf, &child, &["index"])?;
@@ -1197,10 +1197,10 @@ impl DomainSchedule {
                     domain_start_idx = Some(start_index.unwrap());
                 }
                 "domain_idx_shift" => {
-                    if domain_idx_shift.is_some() {
+                    if let Some(domain_idx_shift) = domain_idx_shift {
                         return Err(format!(
                             "Error: Duplicate setting of domain index shift, already set to '{}'",
-                            domain_idx_shift.unwrap()
+                            domain_idx_shift
                         ));
                     }
                     check_attributes(xml_sdf, &child, &["shift"])?;
@@ -2185,9 +2185,7 @@ pub fn parse(filename: &str, xml: &str, config: &Config) -> Result<SystemDescrip
     }
 
     // Ensure that the domain start index (if supplied) points to a valid index
-    if domain_schedule.is_some() {
-        let dom_sched = domain_schedule.as_ref().unwrap();
-
+    if let Some(dom_sched) = &domain_schedule {
         // Make sure we account for the shift when checking if the length of the
         // schedule is valid and if the start index is valid.
         let dom_shift = dom_sched.domain_idx_shift.unwrap_or(0);