Various Improvements

.github/workflows/ci.yml

@@ -14,6 +14,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
+      - run: cargo clippy -- -Dwarnings
       - run: cargo run -- tests/atmega328p.atdf /dev/null
 
   test:

Cargo.toml

@@ -10,7 +10,7 @@ homepage = "https://github.com/Rahix/atdf2svd"
 repository = "https://github.com/Rahix/atdf2svd"
 keywords = ["atdf", "svd", "avr", "svd2rust"]
 categories = ["command-line-utilities", "embedded"]
-edition = "2018"
+edition = "2024"
 
 exclude = [
     "tests/",
@@ -39,6 +39,13 @@ cfg-if = "1.0.0"
 [dev-dependencies]
 insta = { version = "1.41.1", features = ["yaml"] }
 
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+overflow-checks = true
+panic = "abort"
+
 [profile.test.package.insta]
 opt-level = 3
 

src/atdf/chip.rs

@@ -1,6 +1,6 @@
+use crate::ElementExt;
 use crate::atdf;
 use crate::chip;
-use crate::ElementExt;
 use std::collections::BTreeMap;
 
 pub fn parse(el: &xmltree::Element) -> crate::Result<chip::Chip> {
@@ -51,8 +51,8 @@ pub fn parse(el: &xmltree::Element) -> crate::Result<chip::Chip> {
 
     // Map interrupts from <usize, chip::Interrupt> to <std::string::String, chip::Interrupt>
     let interrupts = interrupts
-        .iter()
-        .map(|(_, int)| (int.name.clone(), int.clone()))
+        .values()
+        .map(|int| (int.name.clone(), int.clone()))
         .collect();
 
     Ok(chip::Chip {

src/atdf/field.rs

@@ -1,7 +1,7 @@
+use crate::ElementExt;
 use crate::atdf;
 use crate::chip;
 use crate::util;
-use crate::ElementExt;
 
 pub fn parse(
     bitfield_el: &xmltree::Element,

src/atdf/interrupt.rs

@@ -1,6 +1,6 @@
+use crate::ElementExt;
 use crate::chip;
 use crate::util;
-use crate::ElementExt;
 
 pub fn parse(interrupt: &xmltree::Element) -> crate::Result<chip::Interrupt> {
     debug_assert!(interrupt.name == "interrupt");

src/atdf/patch.rs

@@ -1,7 +1,7 @@
 //! Patches for atdf files that can generally be applied
+use crate::ElementExt;
 use crate::chip;
 use crate::util;
-use crate::ElementExt;
 use std::collections::BTreeMap;
 
 const NEW_PORT_REGS: [&str; 10] = [
@@ -20,7 +20,7 @@ pub fn signals_to_port_fields(chip: &mut chip::Chip, tree: &xmltree::Element) ->
         .values_mut()
         .filter(|p| p.name.starts_with("PORT") && p.name.len() == 5)
     {
-        let name = port.name.chars().rev().next().unwrap();
+        let name = port.name.chars().next_back().unwrap();
 
         let pins: Vec<_> = port_module
             .first_child_by_attr(Some("instance"), "name", &port.name)?

src/atdf/peripheral.rs

@@ -1,7 +1,7 @@
+use crate::ElementExt;
 use crate::atdf;
 use crate::chip;
 use crate::util;
-use crate::ElementExt;
 
 pub fn parse_list(
     el: &xmltree::Element,

src/atdf/register.rs

@@ -1,7 +1,7 @@
+use crate::ElementExt;
 use crate::atdf;
 use crate::chip;
 use crate::util;
-use crate::ElementExt;
 use std::collections::BTreeMap;
 
 fn field_map_from_bitfield_children(

src/atdf/values.rs

@@ -1,6 +1,6 @@
+use crate::ElementExt;
 use crate::chip;
 use crate::util;
-use crate::ElementExt;
 use std::collections::BTreeMap;
 
 pub type ValueGroups = BTreeMap<String, BTreeMap<String, chip::EnumeratedValue>>;

src/error.rs

@@ -1,7 +1,7 @@
 pub trait DisplayError {
     fn format(&self, w: &mut dyn std::io::Write) -> std::io::Result<()>;
 
-    fn into_panic(&self) -> ! {
+    fn to_panic(&self) -> ! {
         let mut message: Vec<u8> = "Error: ".into();
         self.format(&mut message).unwrap();
         panic!("{}", String::from_utf8_lossy(&message));

src/lib.rs

@@ -1,3 +1,7 @@
+#![deny(clippy::as_conversions)]
+// TODO: Remove this at some point when the rustc feature is less new
+#![allow(clippy::collapsible_if)]
+
 #[macro_use]
 pub mod error;
 #[cfg(feature = "cli")]
@@ -87,8 +91,8 @@ pub fn run(args: Atdf2SvdOptions) {
 
 pub fn run_test(atdf: &mut dyn std::io::Read, auto_patches: Vec<&str>) -> String {
     let patches = HashSet::from_iter(auto_patches.iter().map(|s| s.to_string()));
-    let chip = atdf::parse(atdf, &patches).unwrap_or_else(|e| e.into_panic());
+    let chip = atdf::parse(atdf, &patches).unwrap_or_else(|e| e.to_panic());
     let mut output = Vec::new();
-    svd::generate(&chip, &mut output).unwrap_or_else(|e| e.into_panic());
+    svd::generate(&chip, &mut output).unwrap_or_else(|e| e.to_panic());
     String::from_utf8(output).unwrap()
 }

src/svd/field.rs

@@ -5,7 +5,10 @@ use std::convert::TryInto;
 pub fn generate(f: &chip::Field) -> crate::Result<svd_rs::Field> {
     let (write_constraint, enumerated_values) =
         svd::restriction::generate(&f.restriction, f.width().try_into()?)?;
-    let (lsb, msb) = (f.range.0 as u32, f.range.1 as u32);
+    let (lsb, msb) = (
+        u32::try_from(f.range.0).unwrap(),
+        u32::try_from(f.range.1).unwrap(),
+    );
 
     let field = svd_rs::FieldInfo::builder()
         .name(f.name.clone())

src/svd/interrupt.rs

@@ -1,5 +1,5 @@
-use crate::chip;
 use crate::DisplayError;
+use crate::chip;
 use std::convert::TryInto;
 
 pub fn generate(peripherals: &mut [svd_rs::Peripheral], c: &chip::Chip) -> crate::Result<()> {

src/svd/mod.rs

@@ -8,7 +8,7 @@ pub mod restriction;
 pub fn generate<W: std::io::Write>(c: &crate::chip::Chip, mut w: W) -> crate::Result<()> {
     let device = chip::generate(c)?;
     let svd_xml = svd_encoder::encode(&device)?;
-    w.write(svd_xml.as_bytes())?;
+    w.write_all(svd_xml.as_bytes())?;
 
     Ok(())
 }

src/svd/peripheral.rs

@@ -7,10 +7,8 @@ fn create_address_blocks(p: &chip::Peripheral) -> crate::Result<Option<Vec<svd_r
     registers.sort_by(|a, b| a.address.cmp(&b.address));
 
     let base = p.base_address().expect("no base address");
-    let new_address_block = |offset, size| {
-        let offset = (offset as usize - base)
-            .try_into()
-            .map_err(crate::Error::from)?;
+    let new_address_block = |offset: usize, size| {
+        let offset = (offset - base).try_into().map_err(crate::Error::from)?;
 
         svd_rs::AddressBlock::builder()
             .offset(offset)

src/svd/register.rs

@@ -3,17 +3,17 @@ use crate::svd::restriction::generate_access;
 
 pub fn generate(r: &chip::Register, base: u32) -> crate::Result<svd_rs::Register> {
     let (write_constraint, _) =
-        crate::svd::restriction::generate(&r.restriction, r.size as u32 * 8)?;
+        crate::svd::restriction::generate(&r.restriction, u32::try_from(r.size).unwrap() * 8)?;
 
     let register = svd_rs::RegisterInfo::builder()
         .name(r.name.clone())
         .description(r.description.clone().or_else(|| {
             log::warn!("Description missing for register \"{}\"", r.name);
             Some("No Description.".to_owned())
         }))
-        .address_offset(r.address as u32 - base)
+        .address_offset(u32::try_from(r.address).unwrap() - base)
         .size(if r.size != 0 {
-            Some(r.size as u32 * 8)
+            Some(u32::try_from(r.size).unwrap() * 8)
         } else {
             None
         })

src/svd/restriction.rs

@@ -27,13 +27,13 @@ pub fn generate(
             },
             vec![],
         ),
-        chip::ValueRestriction::Range(ref lo, ref hi) => (
+        chip::ValueRestriction::Range(lo, hi) => (
             Some(svd_rs::WriteConstraint::Range(
                 svd_rs::WriteConstraintRange { min: *lo, max: *hi },
             )),
             vec![],
         ),
-        chip::ValueRestriction::Enumerated(ref v) => {
+        chip::ValueRestriction::Enumerated(v) => {
             let mut values = v.values().collect::<Vec<_>>();
             values.sort_by(|a, b| a.value.cmp(&b.value));
 

src/util.rs

@@ -1,6 +1,7 @@
 use std::mem;
 
 /// Parse an integer from either decimal or hexadecimal
+#[expect(clippy::from_str_radix_10)]
 pub fn parse_int(s: &str) -> crate::Result<usize> {
     if let Some(hex) = s.strip_prefix("0x") {
         usize::from_str_radix(hex, 16)