Let-else reformatting (#23)

* Use let-else in App::post_rendering

* Use let-else in diff::reloc_eq

* Use let-else in diff::diff_objs

* Use let-else in views::data_diff::data_diff_ui

* Use let-else in views::function_diff::function_diff_ui

* Use let-else in views::function_diff::asm_row_ui

* Use let-else in views::jobs::jobs_ui

* Update rust-version in Cargo.toml

Author: NickCondron

Cargo.toml

@@ -2,7 +2,7 @@
 name = "objdiff"
 version = "0.2.3"
 edition = "2021"
-rust-version = "1.62"
+rust-version = "1.65"
 authors = ["Luke Street <luke@street.dev>"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/encounter/objdiff"

src/app.rs

@@ -398,69 +398,64 @@ impl eframe::App for App {
 
     fn post_rendering(&mut self, _window_size_px: [u32; 2], _frame: &eframe::Frame) {
         for job in &mut self.view_state.jobs {
-            if let Some(handle) = &job.handle {
-                if !handle.is_finished() {
-                    continue;
-                }
-                match job.handle.take().unwrap().join() {
-                    Ok(result) => {
-                        log::info!("Job {} finished", job.id);
-                        match result {
-                            JobResult::None => {
-                                if let Some(err) = &job.status.read().unwrap().error {
-                                    log::error!("{:?}", err);
-                                }
-                            }
-                            JobResult::ObjDiff(state) => {
-                                self.view_state.build = Some(state);
-                            }
-                            JobResult::BinDiff(state) => {
-                                self.view_state.build = Some(Box::new(ObjDiffResult {
-                                    first_status: BuildStatus {
-                                        success: true,
-                                        log: "".to_string(),
-                                    },
-                                    second_status: BuildStatus {
-                                        success: true,
-                                        log: "".to_string(),
-                                    },
-                                    first_obj: Some(state.first_obj),
-                                    second_obj: Some(state.second_obj),
-                                    time: OffsetDateTime::now_utc(),
-                                }));
-                            }
-                            JobResult::CheckUpdate(state) => {
-                                self.view_state.check_update = Some(state);
-                            }
-                            JobResult::Update(state) => {
-                                if let Ok(mut guard) = self.relaunch_path.lock() {
-                                    *guard = Some(state.exe_path);
-                                }
-                                self.should_relaunch = true;
+            let Some(handle) = &job.handle else {
+                continue;
+            };
+            if !handle.is_finished() {
+                continue;
+            }
+            match job.handle.take().unwrap().join() {
+                Ok(result) => {
+                    log::info!("Job {} finished", job.id);
+                    match result {
+                        JobResult::None => {
+                            if let Some(err) = &job.status.read().unwrap().error {
+                                log::error!("{:?}", err);
                             }
                         }
-                    }
-                    Err(err) => {
-                        let err = if let Some(msg) = err.downcast_ref::<&'static str>() {
-                            anyhow::Error::msg(*msg)
-                        } else if let Some(msg) = err.downcast_ref::<String>() {
-                            anyhow::Error::msg(msg.clone())
-                        } else {
-                            anyhow::Error::msg("Thread panicked")
-                        };
-                        let result = job.status.write();
-                        if let Ok(mut guard) = result {
-                            guard.error = Some(err);
-                        } else {
-                            drop(result);
-                            job.status = Arc::new(RwLock::new(JobStatus {
-                                title: "Error".to_string(),
-                                progress_percent: 0.0,
-                                progress_items: None,
-                                status: "".to_string(),
-                                error: Some(err),
+                        JobResult::ObjDiff(state) => {
+                            self.view_state.build = Some(state);
+                        }
+                        JobResult::BinDiff(state) => {
+                            self.view_state.build = Some(Box::new(ObjDiffResult {
+                                first_status: BuildStatus { success: true, log: "".to_string() },
+                                second_status: BuildStatus { success: true, log: "".to_string() },
+                                first_obj: Some(state.first_obj),
+                                second_obj: Some(state.second_obj),
+                                time: OffsetDateTime::now_utc(),
                             }));
                         }
+                        JobResult::CheckUpdate(state) => {
+                            self.view_state.check_update = Some(state);
+                        }
+                        JobResult::Update(state) => {
+                            if let Ok(mut guard) = self.relaunch_path.lock() {
+                                *guard = Some(state.exe_path);
+                            }
+                            self.should_relaunch = true;
+                        }
+                    }
+                }
+                Err(err) => {
+                    let err = if let Some(msg) = err.downcast_ref::<&'static str>() {
+                        anyhow::Error::msg(*msg)
+                    } else if let Some(msg) = err.downcast_ref::<String>() {
+                        anyhow::Error::msg(msg.clone())
+                    } else {
+                        anyhow::Error::msg("Thread panicked")
+                    };
+                    let result = job.status.write();
+                    if let Ok(mut guard) = result {
+                        guard.error = Some(err);
+                    } else {
+                        drop(result);
+                        job.status = Arc::new(RwLock::new(JobStatus {
+                            title: "Error".to_string(),
+                            progress_percent: 0.0,
+                            progress_items: None,
+                            status: "".to_string(),
+                            error: Some(err),
+                        }));
                     }
                 }
             }

src/diff.rs

@@ -211,25 +211,25 @@ fn address_eq(left: &ObjSymbol, right: &ObjSymbol) -> bool {
 }
 
 fn reloc_eq(left_reloc: Option<&ObjReloc>, right_reloc: Option<&ObjReloc>) -> bool {
-    if let (Some(left), Some(right)) = (left_reloc, right_reloc) {
-        if left.kind != right.kind {
-            return false;
+    let (Some(left), Some(right)) = (left_reloc, right_reloc) else {
+        return false;
+    };
+    if left.kind != right.kind {
+        return false;
+    }
+
+    let name_matches = left.target.name == right.target.name;
+    match (&left.target_section, &right.target_section) {
+        (Some(sl), Some(sr)) => {
+            // Match if section and name or address match
+            sl == sr && (name_matches || address_eq(&left.target, &right.target))
         }
-        let name_matches = left.target.name == right.target.name;
-        match (&left.target_section, &right.target_section) {
-            (Some(sl), Some(sr)) => {
-                // Match if section and name or address match
-                sl == sr && (name_matches || address_eq(&left.target, &right.target))
-            }
-            (Some(_), None) => false,
-            (None, Some(_)) => {
-                // Match if possibly stripped weak symbol
-                name_matches && right.target.flags.0.contains(ObjSymbolFlags::Weak)
-            }
-            (None, None) => name_matches,
+        (Some(_), None) => false,
+        (None, Some(_)) => {
+            // Match if possibly stripped weak symbol
+            name_matches && right.target.flags.0.contains(ObjSymbolFlags::Weak)
         }
-    } else {
-        false
+        (None, None) => name_matches,
     }
 }
 
@@ -363,48 +363,49 @@ fn find_symbol<'a>(symbols: &'a mut [ObjSymbol], name: &str) -> Option<&'a mut O
 
 pub fn diff_objs(left: &mut ObjInfo, right: &mut ObjInfo, _diff_config: &DiffConfig) -> Result<()> {
     for left_section in &mut left.sections {
-        if let Some(right_section) = find_section(right, &left_section.name) {
-            if left_section.kind == ObjSectionKind::Code {
-                for left_symbol in &mut left_section.symbols {
-                    if let Some(right_symbol) =
-                        find_symbol(&mut right_section.symbols, &left_symbol.name)
-                    {
-                        left_symbol.diff_symbol = Some(right_symbol.name.clone());
-                        right_symbol.diff_symbol = Some(left_symbol.name.clone());
-                        diff_code(
-                            left.architecture,
-                            &left_section.data,
-                            &right_section.data,
-                            left_symbol,
-                            right_symbol,
-                            &left_section.relocations,
-                            &right_section.relocations,
-                        )?;
-                    } else {
-                        no_diff_code(
-                            left.architecture,
-                            &left_section.data,
-                            left_symbol,
-                            &left_section.relocations,
-                        )?;
-                    }
+        let Some(right_section) = find_section(right, &left_section.name) else {
+            continue;
+        };
+        if left_section.kind == ObjSectionKind::Code {
+            for left_symbol in &mut left_section.symbols {
+                if let Some(right_symbol) =
+                    find_symbol(&mut right_section.symbols, &left_symbol.name)
+                {
+                    left_symbol.diff_symbol = Some(right_symbol.name.clone());
+                    right_symbol.diff_symbol = Some(left_symbol.name.clone());
+                    diff_code(
+                        left.architecture,
+                        &left_section.data,
+                        &right_section.data,
+                        left_symbol,
+                        right_symbol,
+                        &left_section.relocations,
+                        &right_section.relocations,
+                    )?;
+                } else {
+                    no_diff_code(
+                        left.architecture,
+                        &left_section.data,
+                        left_symbol,
+                        &left_section.relocations,
+                    )?;
                 }
-                for right_symbol in &mut right_section.symbols {
-                    if right_symbol.instructions.is_empty() {
-                        no_diff_code(
-                            left.architecture,
-                            &right_section.data,
-                            right_symbol,
-                            &right_section.relocations,
-                        )?;
-                    }
+            }
+            for right_symbol in &mut right_section.symbols {
+                if right_symbol.instructions.is_empty() {
+                    no_diff_code(
+                        left.architecture,
+                        &right_section.data,
+                        right_symbol,
+                        &right_section.relocations,
+                    )?;
                 }
-            } else if left_section.kind == ObjSectionKind::Data {
-                diff_data(left_section, right_section);
-                // diff_data_symbols(left_section, right_section)?;
-            } else if left_section.kind == ObjSectionKind::Bss {
-                diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
             }
+        } else if left_section.kind == ObjSectionKind::Data {
+            diff_data(left_section, right_section);
+            // diff_data_symbols(left_section, right_section)?;
+        } else if left_section.kind == ObjSectionKind::Bss {
+            diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
         }
     }
     diff_bss_symbols(&mut left.common, &mut right.common)?;